akkartik/sum-grid.love - Change MD3W5IRAC6UQALQE4LJC52VQNDO3I3HXF3XE2XHDABXBYJBUVAXQC

new fork: rip out drawing support

Created by Kartik K. Agaram on August 14, 2022

MD3W5IRAC6UQALQE4LJC52VQNDO3I3HXF3XE2XHDABXBYJBUVAXQC

Dependencies

In channels

main

Change contents

File deletion: drawing_tests.lua

BF:BFD[27.2] → [28.1534:1575]

BF:BFD[28.1575] → [28.15:15]

B:BD[28.15] → [28.16:193]

∅:D[29.481] → [28.193:353]

B:BD[28.193] → [28.193:353]

∅:D[30.9697] → [31.106311:106470]

B:BD[32.1357] → [31.106311:106470]

∅:D[13.380] → [31.106597:106755]

∅:D[33.742] → [31.106597:106755]

∅:D[34.23610] → [31.106597:106755]

B:BD[31.106597] → [31.106597:106755]

∅:D[31.106755] → [28.907:924]

B:BD[28.907] → [28.907:924]

∅:D[33.961] → [31.106998:107038]

∅:D[35.7637] → [31.106998:107038]

∅:D[34.23855] → [31.106998:107038]

B:BD[31.106998] → [31.106998:107038]

∅:D[31.107038] → [36.15:137]

B:BD[28.1239] → [36.15:137]

∅:D[36.137] → [37.52:125]

B:BD[28.1239] → [37.52:125]

∅:D[37.125] → [28.1239:1529]

B:BD[28.1239] → [28.1239:1529]

∅:D[37.5746] → [28.1529:1533]

B:BD[28.1529] → [28.1529:1533]

B:BD[28.1533] → [37.5747:5906]

∅:D[30.9859] → [31.112013:112170]

B:BD[32.1447] → [31.112013:112170]

∅:D[13.999] → [31.112296:112452]

∅:D[33.2717] → [31.112296:112452]

∅:D[34.27007] → [31.112296:112452]

B:BD[31.112296] → [31.112296:112452]

∅:D[31.112452] → [37.6457:6474]

B:BD[37.6457] → [37.6457:6474]

∅:D[33.3037] → [31.112823:112863]

∅:D[35.9277] → [31.112823:112863]

∅:D[34.27366] → [31.112823:112863]

B:BD[31.112823] → [31.112823:112863]

∅:D[33.2910] → [35.9066:9124]

∅:D[34.27226] → [35.9066:9124]

B:BD[31.112684] → [35.9066:9124]

B:BD[35.9124] → [33.2911:3037]

∅:D[31.112863] → [36.559:619]

B:BD[37.6918] → [36.559:619]

∅:D[7.74] → [37.6918:7381]

∅:D[36.679] → [37.6918:7381]

B:BD[37.6918] → [37.6918:7381]

B:BD[37.7381] → [36.680:847]

∅:D[30.9886] → [31.113029:113295]

B:BD[32.1462] → [31.113029:113295]

∅:D[13.1120] → [31.113425:113589]

∅:D[33.3148] → [31.113425:113589]

∅:D[34.27688] → [31.113425:113589]

B:BD[31.113425] → [31.113425:113589]

∅:D[31.113589] → [36.1472:1489]

B:BD[36.1472] → [36.1472:1489]

∅:D[33.3256] → [35.9412:9474]

∅:D[34.27809] → [35.9412:9474]

B:BD[35.9412] → [35.9412:9474]

∅:D[35.9474] → [36.1616:1634]

B:BD[36.1616] → [36.1616:1634]

∅:D[33.3337] → [35.9475:9534]

∅:D[34.27903] → [35.9475:9534]

B:BD[31.113817] → [35.9475:9534]

∅:D[35.9534] → [36.1746:1763]

B:BD[36.1746] → [36.1746:1763]

∅:D[33.3449] → [31.113941:113981]

∅:D[35.9673] → [31.113941:113981]

∅:D[34.28028] → [31.113941:113981]

B:BD[31.113941] → [31.113941:113981]

∅:D[31.113981] → [36.1874:2783]

B:BD[36.1874] → [36.1874:2783]

∅:D[30.9913] → [31.114147:114419]

B:BD[32.1477] → [31.114147:114419]

∅:D[13.1243] → [31.114551:114719]

∅:D[33.3562] → [31.114551:114719]

∅:D[34.28352] → [31.114551:114719]

B:BD[31.114551] → [31.114551:114719]

∅:D[31.114719] → [36.3420:3437]

B:BD[36.3420] → [36.3420:3437]

∅:D[33.3672] → [35.9810:9874]

∅:D[34.28475] → [35.9810:9874]

B:BD[35.9810] → [35.9810:9874]

∅:D[35.9874] → [36.3568:3597]

B:BD[36.3568] → [36.3568:3597]

∅:D[33.3753] → [35.9875:9920]

∅:D[34.28569] → [35.9875:9920]

B:BD[31.114949] → [35.9875:9920]

∅:D[35.9920] → [36.3695:3733]

B:BD[36.3695] → [36.3695:3733]

∅:D[33.3834] → [35.9921:9966]

∅:D[34.28663] → [35.9921:9966]

B:BD[31.115057] → [35.9921:9966]

∅:D[35.9966] → [36.3831:3907]

B:BD[36.3831] → [36.3831:3907]

∅:D[33.3946] → [31.115181:115221]

∅:D[35.10105] → [31.115181:115221]

∅:D[34.28788] → [31.115181:115221]

B:BD[31.115181] → [31.115181:115221]

∅:D[31.115221] → [36.4018:5167]

B:BD[36.4018] → [36.4018:5167]

∅:D[30.9940] → [31.115387:115698]

B:BD[32.1492] → [31.115387:115698]

∅:D[13.1379] → [31.115843:116037]

∅:D[33.4072] → [31.115843:116037]

∅:D[34.29125] → [31.115843:116037]

B:BD[31.115843] → [31.115843:116037]

∅:D[31.116037] → [36.5882:5899]

B:BD[36.5882] → [36.5882:5899]

∅:D[33.4182] → [35.10242:10306]

∅:D[34.29248] → [35.10242:10306]

B:BD[35.10242] → [35.10242:10306]

∅:D[35.10306] → [36.6030:6059]

B:BD[36.6030] → [36.6030:6059]

∅:D[33.4263] → [35.10307:10352]

∅:D[34.29342] → [35.10307:10352]

B:BD[31.116267] → [35.10307:10352]

∅:D[35.10352] → [36.6157:6195]

B:BD[36.6157] → [36.6157:6195]

∅:D[35.10398] → [31.116376:116416]

B:BD[36.6293] → [31.116376:116416]

∅:D[33.4344] → [35.10353:10398]

∅:D[34.29436] → [35.10353:10398]

B:BD[31.116375] → [35.10353:10398]

∅:D[31.116416] → [36.6320:7265]

B:BD[36.6320] → [36.6320:7265]

∅:D[30.9967] → [31.116582:116845]

B:BD[32.1507] → [31.116582:116845]

∅:D[13.1499] → [31.116974:117136]

∅:D[33.4454] → [31.116974:117136]

∅:D[34.29757] → [31.116974:117136]

B:BD[31.116974] → [31.116974:117136]

∅:D[31.117136] → [36.7884:7901]

B:BD[36.7884] → [36.7884:7901]

∅:D[33.4564] → [35.10535:10596]

∅:D[34.29880] → [35.10535:10596]

B:BD[35.10535] → [35.10535:10596]

∅:D[35.10596] → [36.8029:8058]

B:BD[36.8029] → [36.8029:8058]

∅:D[33.4645] → [35.10597:10642]

∅:D[34.29974] → [35.10597:10642]

B:BD[31.117366] → [35.10597:10642]

∅:D[35.10642] → [36.8156:8194]

B:BD[36.8156] → [36.8156:8194]

∅:D[33.4726] → [35.10643:10688]

∅:D[34.30068] → [35.10643:10688]

B:BD[31.117474] → [35.10643:10688]

∅:D[35.10688] → [36.8292:8358]

B:BD[36.8292] → [36.8292:8358]

∅:D[33.4838] → [31.117598:117638]

∅:D[35.10827] → [31.117598:117638]

∅:D[34.30193] → [31.117598:117638]

B:BD[31.117598] → [31.117598:117638]

∅:D[31.117638] → [36.8469:9419]

B:BD[36.8469] → [36.8469:9419]

B:BD[36.9419] → [38.148:242]

∅:D[12.114] → [31.117778:117835]

∅:D[39.7517] → [31.117778:117835]

∅:D[34.30391] → [31.117778:117835]

B:BD[31.117778] → [31.117778:117835]

∅:D[40.9033] → [31.117835:117880]

B:BD[31.117835] → [31.117835:117880]

B:BD[31.117880] → [30.9968:9994]

B:BD[31.117835] → [40.9001:9033]

B:BD[31.117671] → [39.7373:7517]

B:BD[39.7517] → [12.82:114]

∅:D[32.1522] → [38.443:460]

∅:D[30.9994] → [38.443:460]

B:BD[38.443] → [38.443:460]

∅:D[33.5057] → [31.118123:118163]

∅:D[35.11100] → [31.118123:118163]

∅:D[34.30636] → [31.118123:118163]

B:BD[31.118123] → [31.118123:118163]

∅:D[31.118163] → [38.651:1315]

B:BD[38.651] → [38.651:1315]

∅:D[35.11148] → [31.118164:118248]

B:BD[38.1347] → [31.118164:118248]

∅:D[35.11195] → [38.1449:1523]

B:BD[38.1449] → [38.1449:1523]

∅:D[31.118333] → [38.1594:1616]

B:BD[38.1594] → [38.1594:1616]

∅:D[35.11246] → [31.118334:118418]

B:BD[38.1651] → [31.118334:118418]

∅:D[31.118418] → [38.1722:1770]

B:BD[38.1722] → [38.1722:1770]

∅:D[41.1938] → [38.1770:1774]

∅:D[42.4208] → [38.1770:1774]

B:BD[38.1770] → [38.1770:1774]

B:BD[38.1774] → [42.4209:4357]

∅:D[39.8387] → [31.123295:123352]

∅:D[34.34323] → [31.123295:123352]

B:BD[31.123295] → [31.123295:123352]

∅:D[40.9363] → [31.123352:123397]

B:BD[31.123352] → [31.123352:123397]

B:BD[31.123397] → [30.10184:10210]

B:BD[31.123352] → [40.9331:9363]

∅:D[32.1642] → [42.4558:4575]

∅:D[30.10210] → [42.4558:4575]

B:BD[42.4558] → [42.4558:4575]

∅:D[33.7378] → [35.13854:13916]

∅:D[34.34444] → [35.13854:13916]

B:BD[35.13854] → [35.13854:13916]

∅:D[35.13916] → [42.4702:4720]

B:BD[42.4702] → [42.4702:4720]

∅:D[33.7459] → [35.13917:13976]

∅:D[34.34538] → [35.13917:13976]

B:BD[31.123625] → [35.13917:13976]

∅:D[35.13976] → [42.4832:4849]

B:BD[42.4832] → [42.4832:4849]

∅:D[33.7571] → [31.123749:123789]

∅:D[35.14115] → [31.123749:123789]

∅:D[34.34663] → [31.123749:123789]

B:BD[31.123749] → [31.123749:123789]

∅:D[31.123789] → [42.4960:5276]

B:BD[42.4960] → [42.4960:5276]

∅:D[33.7652] → [35.14116:14163]

∅:D[34.34757] → [35.14116:14163]

B:BD[31.123897] → [35.14116:14163]

∅:D[35.14163] → [42.5376:5526]

B:BD[42.5376] → [42.5376:5526]

B:BD[42.5526] → [43.88:192]

∅:D[12.246] → [31.124037:124094]

∅:D[39.8532] → [31.124037:124094]

∅:D[34.34955] → [31.124037:124094]

B:BD[31.124037] → [31.124037:124094]

∅:D[40.9396] → [31.124094:124139]

B:BD[31.124094] → [31.124094:124139]

B:BD[31.124139] → [30.10211:10237]

B:BD[31.124094] → [40.9364:9396]

B:BD[31.123930] → [39.8388:8532]

B:BD[39.8532] → [12.214:246]

∅:D[32.1657] → [43.412:429]

∅:D[30.10237] → [43.412:429]

B:BD[43.412] → [43.412:429]

∅:D[33.7871] → [31.124382:124422]

∅:D[35.14436] → [31.124382:124422]

∅:D[34.35200] → [31.124382:124422]

B:BD[31.124382] → [31.124382:124422]

∅:D[31.124422] → [43.620:1276]

B:BD[43.620] → [43.620:1276]

∅:D[44.453] → [43.1347:1395]

∅:D[31.124507] → [43.1347:1395]

B:BD[43.1347] → [43.1347:1395]

∅:D[35.14580] → [43.1493:1555]

B:BD[43.1493] → [43.1493:1555]

∅:D[44.507] → [43.1704:1714]

∅:D[31.124683] → [43.1704:1714]

B:BD[43.1704] → [43.1704:1714]

∅:D[35.14628] → [31.124684:124724]

B:BD[43.1746] → [31.124684:124724]

∅:D[31.124724] → [43.1773:1823]

B:BD[43.1773] → [43.1773:1823]

∅:D[31.124807] → [43.1892:1995]

B:BD[43.1892] → [43.1892:1995]

∅:D[31.124933] → [43.2102:2163]

B:BD[43.2102] → [43.2102:2163]

B:BD[43.2163] → [45.14:118]

∅:D[33.8090] → [31.125418:125458]

∅:D[35.14901] → [31.125418:125458]

∅:D[34.35643] → [31.125418:125458]

B:BD[31.125418] → [31.125418:125458]

∅:D[31.125458] → [45.529:1198]

B:BD[45.529] → [45.529:1198]

∅:D[46.379] → [45.1317:1491]

B:BD[45.1317] → [45.1317:1491]

∅:D[33.8281] → [31.125688:125770]

∅:D[35.15086] → [31.125688:125770]

∅:D[34.35860] → [31.125688:125770]

B:BD[31.125688] → [31.125688:125770]

∅:D[31.125770] → [45.1642:1652]

B:BD[45.1642] → [45.1642:1652]

∅:D[35.15209] → [31.125771:125811]

B:BD[45.1744] → [31.125771:125811]

∅:D[31.125811] → [45.1771:1821]

B:BD[45.1771] → [45.1771:1821]

∅:D[31.125894] → [45.1890:1992]

B:BD[45.1890] → [45.1890:1992]

∅:D[31.126020] → [45.2099:2211]

B:BD[45.2099] → [45.2099:2211]

∅:D[47.1806] → [45.2211:2215]

∅:D[31.127163] → [45.2211:2215]

B:BD[45.2211] → [45.2211:2215]

B:BD[45.2211] → [47.54:190]

∅:D[33.8720] → [31.126749:126789]

∅:D[35.15756] → [31.126749:126789]

∅:D[34.36549] → [31.126749:126789]

B:BD[31.126749] → [31.126749:126789]

∅:D[31.126789] → [47.767:1067]

B:BD[47.767] → [47.767:1067]

∅:D[33.8801] → [35.15757:15804]

∅:D[34.36643] → [35.15757:15804]

B:BD[31.126897] → [35.15757:15804]

∅:D[35.15804] → [47.1167:1345]

B:BD[47.1167] → [47.1167:1345]

∅:D[35.15852] → [31.126898:126938]

B:BD[47.1377] → [31.126898:126938]

∅:D[31.126938] → [47.1404:1454]

B:BD[47.1404] → [47.1404:1454]

∅:D[31.127021] → [47.1523:1685]

B:BD[47.1523] → [47.1523:1685]

∅:D[46.443] → [47.1685:1704]

∅:D[48.1494] → [47.1685:1704]

B:BD[47.1685] → [47.1685:1704]

∅:D[15.727] → [40.9529:9561]

B:BD[31.127083] → [40.9529:9561]

∅:D[40.9561] → [31.127083:127163]

B:BD[31.127083] → [31.127083:127163]

B:BD[47.1704] → [15.696:727]

B:BD[47.1685] → [48.1431:1478]

B:BD[48.1478] → [46.412:443]

B:BD[47.1454] → [31.126939:127021]

B:BD[47.1345] → [35.15805:15852]

B:BD[47.1067] → [33.8721:8801]

∅:D[12.312] → [31.126160:126217]

∅:D[39.8822] → [31.126160:126217]

∅:D[34.36058] → [31.126160:126217]

B:BD[31.126160] → [31.126160:126217]

∅:D[40.9528] → [31.126217:126262]

B:BD[31.126217] → [31.126217:126262]

B:BD[31.126262] → [30.10265:10291]

B:BD[30.10291] → [33.8282:8720]

B:BD[31.126217] → [40.9496:9528]

B:BD[31.126053] → [39.8678:8822]

B:BD[39.8822] → [12.280:312]

B:BD[45.1992] → [48.1367:1414]

B:BD[48.1414] → [46.380:411]

∅:D[46.411] → [47.34:53]

∅:D[48.1430] → [47.34:53]

B:BD[45.1992] → [47.34:53]

∅:D[15.695] → [40.9463:9495]

B:BD[31.125956] → [40.9463:9495]

∅:D[40.9495] → [31.125956:126020]

B:BD[31.125956] → [31.125956:126020]

B:BD[47.53] → [15.664:695]

B:BD[45.1821] → [31.125812:125894]

B:BD[45.1652] → [35.15087:15209]

B:BD[45.1491] → [33.8172:8281]

B:BD[45.1198] → [35.14902:14949]

∅:D[33.8171] → [46.345:379]

B:BD[34.35737] → [46.345:379]

B:BD[35.14949] → [33.8091:8171]

∅:D[12.279] → [31.125073:125130]

∅:D[39.8677] → [31.125073:125130]

∅:D[34.35398] → [31.125073:125130]

B:BD[31.125073] → [31.125073:125130]

∅:D[40.9462] → [31.125130:125175]

B:BD[31.125130] → [31.125130:125175]

B:BD[31.125175] → [30.10238:10264]

B:BD[30.10264] → [33.7872:8090]

B:BD[31.125130] → [40.9430:9462]

B:BD[31.124966] → [39.8533:8677]

B:BD[39.8677] → [12.247:279]

B:BD[43.1995] → [48.1303:1350]

B:BD[48.1350] → [46.313:344]

∅:D[46.344] → [47.14:33]

∅:D[48.1366] → [47.14:33]

B:BD[43.1995] → [47.14:33]

∅:D[15.663] → [40.9397:9429]

B:BD[31.124869] → [40.9397:9429]

∅:D[40.9429] → [31.124869:124933]

B:BD[31.124869] → [31.124869:124933]

B:BD[47.33] → [15.632:663]

B:BD[43.1823] → [31.124725:124807]

B:BD[43.1714] → [35.14581:14628]

B:BD[43.1555] → [31.124508:124683]

B:BD[31.124683] → [44.454:507]

B:BD[43.1395] → [35.14437:14580]

B:BD[43.1276] → [31.124423:124507]

B:BD[31.124507] → [44.400:453]

B:BD[43.429] → [33.7653:7871]

B:BD[42.5276] → [33.7572:7652]

B:BD[42.4849] → [33.7460:7571]

B:BD[42.4720] → [33.7379:7459]

B:BD[42.4575] → [33.7271:7378]

B:BD[42.4357] → [39.8243:8387]

B:BD[38.1770] → [48.1044:1091]

B:BD[48.1091] → [46.115:146]

∅:D[46.146] → [49.34:55]

∅:D[48.1107] → [49.34:55]

B:BD[38.1770] → [49.34:55]

∅:D[15.535] → [40.9034:9066]

B:BD[31.118480] → [40.9034:9066]

∅:D[40.9066] → [31.118480:118544]

B:BD[31.118480] → [31.118480:118544]

∅:D[31.118544] → [49.141:194]

B:BD[49.141] → [49.141:194]

B:BD[49.55] → [15.504:535]

∅:D[49.194] → [41.14:112]

B:BD[38.1770] → [41.14:112]

∅:D[33.5276] → [31.119029:119069]

∅:D[35.11519] → [31.119029:119069]

∅:D[34.31079] → [31.119029:119069]

B:BD[31.119029] → [31.119029:119069]

∅:D[31.119069] → [41.521:1076]

B:BD[41.521] → [41.521:1076]

B:BD[41.1137] → [48.1108:1155]

∅:D[46.178] → [49.215:242]

∅:D[48.1171] → [49.215:242]

B:BD[41.1137] → [49.215:242]

∅:D[15.567] → [40.9100:9132]

B:BD[31.119131] → [40.9100:9132]

∅:D[40.9132] → [31.119131:119235]

B:BD[31.119131] → [31.119131:119235]

∅:D[31.119235] → [49.355:457]

B:BD[49.355] → [49.355:457]

∅:D[49.470] → [41.1137:1185]

∅:D[32.1552] → [41.1137:1185]

∅:D[30.10048] → [41.1137:1185]

B:BD[41.1137] → [41.1137:1185]

∅:D[35.11567] → [31.119236:119320]

B:BD[41.1217] → [31.119236:119320]

∅:D[31.119320] → [41.1288:1471]

B:BD[41.1288] → [41.1288:1471]

∅:D[46.213] → [41.1558:1722]

B:BD[41.1558] → [41.1558:1722]

∅:D[33.5467] → [31.119550:119634]

∅:D[35.11704] → [31.119550:119634]

∅:D[34.31296] → [31.119550:119634]

B:BD[31.119550] → [31.119550:119634]

∅:D[31.119634] → [41.1875:1938]

B:BD[41.1875] → [41.1875:1938]

B:BD[41.1938] → [48.1172:1219]

B:BD[48.1219] → [46.214:245]

∅:D[46.245] → [49.471:492]

∅:D[48.1235] → [49.471:492]

B:BD[41.1938] → [49.471:492]

∅:D[15.599] → [40.9133:9165]

B:BD[31.119696] → [40.9133:9165]

∅:D[40.9165] → [31.119696:119760]

B:BD[31.119696] → [31.119696:119760]

∅:D[31.119760] → [49.578:680]

B:BD[49.578] → [49.578:680]

B:BD[49.492] → [15.568:599]

∅:D[49.680] → [42.14:19]

B:BD[41.1938] → [42.14:19]

∅:D[50.1253] → [42.19:158]

B:BD[42.19] → [42.19:158]

∅:D[33.6206] → [31.121230:121270]

∅:D[35.12572] → [31.121230:121270]

∅:D[34.32522] → [31.121230:121270]

B:BD[31.121230] → [31.121230:121270]

∅:D[31.121270] → [42.716:1028]

B:BD[42.716] → [42.716:1028]

∅:D[33.6287] → [35.12573:12620]

∅:D[34.32616] → [35.12573:12620]

B:BD[31.121378] → [35.12573:12620]

∅:D[35.12620] → [42.1128:1304]

B:BD[42.1128] → [42.1128:1304]

∅:D[49.860] → [42.1304:1468]

∅:D[31.121524] → [42.1304:1468]

B:BD[42.1304] → [42.1304:1468]

∅:D[33.6726] → [31.122221:122261]

∅:D[35.13167] → [31.122221:122261]

∅:D[34.33305] → [31.122221:122261]

B:BD[31.122221] → [31.122221:122261]

∅:D[31.122261] → [42.2026:2368]

B:BD[42.2026] → [42.2026:2368]

∅:D[33.6807] → [35.13168:13215]

∅:D[34.33399] → [35.13168:13215]

B:BD[31.122369] → [35.13168:13215]

∅:D[35.13215] → [42.2468:2844]

B:BD[42.2468] → [42.2468:2844]

∅:D[39.8242] → [31.122477:122534]

∅:D[34.33597] → [31.122477:122534]

B:BD[31.122477] → [31.122477:122534]

∅:D[40.9330] → [31.122534:122579]

B:BD[31.122534] → [31.122534:122579]

B:BD[31.122579] → [30.10157:10183]

B:BD[31.122534] → [40.9298:9330]

∅:D[32.1627] → [42.3045:3062]

∅:D[30.10183] → [42.3045:3062]

B:BD[42.3045] → [42.3045:3062]

∅:D[33.6915] → [35.13350:13412]

∅:D[34.33718] → [35.13350:13412]

B:BD[35.13350] → [35.13350:13412]

∅:D[35.13412] → [42.3189:3207]

B:BD[42.3189] → [42.3189:3207]

∅:D[33.6996] → [35.13413:13472]

∅:D[34.33812] → [35.13413:13472]

B:BD[31.122807] → [35.13413:13472]

∅:D[35.13472] → [42.3319:3336]

B:BD[42.3319] → [42.3319:3336]

∅:D[33.7077] → [35.13473:13532]

∅:D[34.33906] → [35.13473:13532]

B:BD[31.122915] → [35.13473:13532]

∅:D[35.13532] → [42.3448:3466]

B:BD[42.3448] → [42.3448:3466]

∅:D[33.7189] → [31.123039:123079]

∅:D[35.13671] → [31.123039:123079]

∅:D[34.34031] → [31.123039:123079]

B:BD[31.123039] → [31.123039:123079]

∅:D[31.123079] → [42.3577:3893]

B:BD[42.3577] → [42.3577:3893]

∅:D[33.7270] → [35.13672:13719]

∅:D[34.34125] → [35.13672:13719]

B:BD[31.123187] → [35.13672:13719]

∅:D[35.13719] → [42.3993:4208]

B:BD[42.3993] → [42.3993:4208]

B:BD[42.3893] → [33.7190:7270]

B:BD[42.3466] → [33.7078:7189]

B:BD[42.3336] → [33.6997:7077]

B:BD[42.3207] → [33.6916:6996]

B:BD[42.3062] → [33.6808:6915]

B:BD[42.2844] → [39.8098:8242]

B:BD[42.2368] → [33.6727:6807]

∅:D[39.8097] → [31.121632:121689]

∅:D[34.32814] → [31.121632:121689]

B:BD[31.121632] → [31.121632:121689]

∅:D[40.9297] → [31.121689:121734]

B:BD[31.121689] → [31.121689:121734]

B:BD[31.121734] → [30.10130:10156]

B:BD[30.10156] → [33.6288:6726]

B:BD[31.121689] → [40.9265:9297]

B:BD[42.1468] → [39.7953:8097]

B:BD[42.1304] → [48.1236:1286]

B:BD[48.1286] → [46.281:312]

∅:D[46.312] → [49.701:754]

∅:D[48.1302] → [49.701:754]

B:BD[42.1304] → [49.701:754]

∅:D[15.631] → [40.9232:9264]

B:BD[31.121440] → [40.9232:9264]

∅:D[40.9264] → [31.121440:121524]

B:BD[31.121440] → [31.121440:121524]

B:BD[49.754] → [15.600:631]

B:BD[42.1028] → [33.6207:6287]

∅:D[12.213] → [31.120641:120698]

∅:D[39.7952] → [31.120641:120698]

∅:D[34.32031] → [31.120641:120698]

B:BD[31.120641] → [31.120641:120698]

∅:D[40.9231] → [31.120698:120743]

B:BD[31.120698] → [31.120698:120743]

B:BD[31.120743] → [30.10103:10129]

B:BD[30.10129] → [33.5768:6206]

B:BD[31.120698] → [40.9199:9231]

B:BD[31.120534] → [39.7808:7952]

B:BD[39.7952] → [12.181:213]

B:BD[42.19] → [50.15:154]

∅:D[33.5686] → [31.120250:120290]

∅:D[35.11977] → [31.120250:120290]

∅:D[34.31739] → [31.120250:120290]

B:BD[31.120250] → [31.120250:120290]

∅:D[31.120290] → [50.570:854]

B:BD[50.570] → [50.570:854]

∅:D[32.1582] → [50.867:890]

∅:D[30.10102] → [50.867:890]

B:BD[50.867] → [50.867:890]

∅:D[35.12025] → [31.120291:120393]

B:BD[50.922] → [31.120291:120393]

∅:D[31.120393] → [50.1011:1027]

B:BD[50.1011] → [50.1011:1027]

∅:D[46.280] → [50.1114:1253]

B:BD[50.1114] → [50.1114:1253]

∅:D[33.5767] → [46.246:280]

B:BD[34.31833] → [46.246:280]

B:BD[50.1027] → [33.5687:5767]

B:BD[50.890] → [35.11978:12025]

B:BD[50.854] → [30.10076:10102]

∅:D[12.180] → [31.119900:119957]

∅:D[39.7807] → [31.119900:119957]

∅:D[34.31494] → [31.119900:119957]

B:BD[31.119900] → [31.119900:119957]

∅:D[40.9198] → [31.119957:120007]

B:BD[31.119957] → [31.119957:120007]

B:BD[31.120007] → [30.10049:10075]

B:BD[30.10075] → [33.5468:5686]

B:BD[31.119957] → [40.9166:9198]

B:BD[31.119793] → [39.7663:7807]

B:BD[39.7807] → [12.148:180]

B:BD[41.1722] → [33.5358:5467]

∅:D[33.5357] → [46.179:213]

B:BD[34.31173] → [46.179:213]

B:BD[41.1471] → [33.5277:5357]

B:BD[41.1185] → [35.11520:11567]

B:BD[49.457] → [30.10022:10048]

B:BD[49.242] → [15.536:567]

B:BD[48.1155] → [46.147:178]

∅:D[12.147] → [31.118684:118741]

∅:D[39.7662] → [31.118684:118741]

∅:D[34.30834] → [31.118684:118741]

B:BD[31.118684] → [31.118684:118741]

∅:D[40.9099] → [31.118741:118786]

B:BD[31.118741] → [31.118741:118786]

B:BD[31.118786] → [30.9995:10021]

B:BD[30.10021] → [33.5058:5276]

B:BD[31.118741] → [40.9067:9099]

B:BD[31.118577] → [39.7518:7662]

B:BD[39.7662] → [12.115:147]

B:BD[38.1616] → [35.11196:11246]

B:BD[38.1523] → [31.118249:118333]

B:BD[31.118248] → [35.11149:11195]

B:BD[38.1315] → [35.11101:11148]

B:BD[38.460] → [33.4839:5057]

B:BD[36.8358] → [33.4727:4838]

B:BD[36.8194] → [33.4646:4726]

B:BD[36.8058] → [33.4565:4645]

B:BD[36.7901] → [33.4455:4564]

B:BD[31.116845] → [13.1380:1499]

∅:D[39.7372] → [31.116524:116581]

∅:D[34.29634] → [31.116524:116581]

B:BD[31.116524] → [31.116524:116581]

∅:D[40.9000] → [30.9941:9967]

B:BD[31.116581] → [30.9941:9967]

B:BD[31.116581] → [40.8968:9000]

B:BD[36.7265] → [39.7228:7372]

B:BD[36.6195] → [33.4264:4344]

B:BD[36.6059] → [33.4183:4263]

B:BD[36.5899] → [33.4073:4182]

B:BD[31.115698] → [13.1244:1379]

∅:D[39.7227] → [31.115329:115386]

∅:D[34.28986] → [31.115329:115386]

B:BD[31.115329] → [31.115329:115386]

∅:D[40.8967] → [30.9914:9940]

B:BD[31.115386] → [30.9914:9940]

B:BD[31.115386] → [40.8935:8967]

B:BD[36.5167] → [39.7083:7227]

B:BD[36.3907] → [33.3835:3946]

B:BD[36.3733] → [33.3754:3834]

B:BD[36.3597] → [33.3673:3753]

B:BD[36.3437] → [33.3563:3672]

B:BD[31.114419] → [13.1121:1243]

∅:D[39.7082] → [31.114089:114146]

∅:D[34.28226] → [31.114089:114146]

B:BD[31.114089] → [31.114089:114146]

∅:D[40.8934] → [30.9887:9913]

B:BD[31.114146] → [30.9887:9913]

B:BD[31.114146] → [40.8902:8934]

B:BD[36.2783] → [39.6938:7082]

B:BD[36.1763] → [33.3338:3449]

B:BD[36.1634] → [33.3257:3337]

B:BD[36.1489] → [33.3149:3256]

B:BD[31.113295] → [13.1000:1120]

∅:D[39.6937] → [31.112971:113028]

∅:D[34.27564] → [31.112971:113028]

B:BD[31.112971] → [31.112971:113028]

∅:D[40.8901] → [30.9860:9886]

B:BD[31.113028] → [30.9860:9886]

B:BD[31.113028] → [40.8869:8901]

B:BD[36.847] → [39.6793:6937]

B:BD[36.619] → [7.14:74]

B:BD[37.6474] → [33.2718:2910]

B:BD[31.112170] → [13.883:999]

∅:D[39.6792] → [31.111908:111965]

∅:D[34.26887] → [31.111908:111965]

B:BD[31.111908] → [31.111908:111965]

∅:D[40.8868] → [31.111965:112012]

B:BD[31.111965] → [31.111965:112012]

B:BD[31.112012] → [30.9833:9859]

B:BD[31.111965] → [40.8836:8868]

B:BD[37.5906] → [39.6648:6792]

B:BD[28.1529] → [48.980:1027]

B:BD[48.1027] → [46.83:114]

∅:D[46.114] → [29.502:622]

∅:D[48.1043] → [29.502:622]

B:BD[28.1529] → [29.502:622]

∅:D[15.503] → [40.8638:8670]

B:BD[31.107100] → [40.8638:8670]

∅:D[40.8670] → [31.107100:107140]

B:BD[31.107100] → [31.107100:107140]

∅:D[31.107140] → [29.684:1204]

B:BD[29.684] → [29.684:1204]

B:BD[29.622] → [15.472:503]

∅:D[29.1204] → [37.126:313]

B:BD[28.1529] → [37.126:313]

∅:D[30.9724] → [31.107356:107537]

B:BD[32.1372] → [31.107356:107537]

∅:D[13.509] → [31.107675:107855]

∅:D[33.1080] → [31.107675:107855]

∅:D[34.24185] → [31.107675:107855]

B:BD[31.107675] → [31.107675:107855]

∅:D[31.107855] → [37.927:982]

B:BD[37.927] → [37.927:982]

∅:D[33.1299] → [31.108098:108138]

∅:D[35.7910] → [31.108098:108138]

∅:D[34.24430] → [31.108098:108138]

B:BD[31.108098] → [31.108098:108138]

∅:D[31.108138] → [36.138:282]

B:BD[37.1319] → [36.138:282]

∅:D[36.282] → [37.1319:1916]

B:BD[37.1319] → [37.1319:1916]

∅:D[30.9751] → [31.108349:108512]

B:BD[32.1387] → [31.108349:108512]

∅:D[13.629] → [31.108641:108803]

∅:D[33.1409] → [31.108641:108803]

∅:D[34.24751] → [31.108641:108803]

B:BD[31.108641] → [31.108641:108803]

∅:D[31.108803] → [37.2480:2499]

B:BD[37.2480] → [37.2480:2499]

∅:D[33.1733] → [31.109178:109218]

∅:D[35.8235] → [31.109178:109218]

∅:D[34.25114] → [31.109178:109218]

B:BD[31.109178] → [31.109178:109218]

∅:D[33.1509] → [35.7911:7958]

∅:D[34.24864] → [35.7911:7958]

B:BD[31.108930] → [35.7911:7958]

B:BD[35.7958] → [33.1510:1733]

∅:D[31.109218] → [36.283:409]

B:BD[37.2942] → [36.283:409]

∅:D[36.409] → [37.2942:3277]

B:BD[37.2942] → [37.2942:3277]

∅:D[51.1092] → [37.3277:3500]

B:BD[37.3277] → [37.3277:3500]

∅:D[39.6502] → [31.110317:110374]

∅:D[34.25881] → [31.110317:110374]

B:BD[31.110317] → [31.110317:110374]

∅:D[40.8802] → [31.110374:110419]

B:BD[31.110374] → [31.110374:110419]

B:BD[31.110419] → [30.9779:9805]

B:BD[31.110374] → [40.8770:8802]

∅:D[32.1417] → [37.3701:3761]

∅:D[30.9805] → [37.3701:3761]

B:BD[37.3701] → [37.3701:3761]

∅:D[33.2165] → [35.8560:8605]

∅:D[34.25994] → [35.8560:8605]

B:BD[31.110546] → [35.8560:8605]

∅:D[35.8605] → [37.3878:3909]

B:BD[37.3878] → [37.3878:3909]

∅:D[31.110665] → [37.4014:4277]

B:BD[37.4014] → [37.4014:4277]

∅:D[30.9832] → [31.110876:111061]

B:BD[32.1432] → [31.110876:111061]

∅:D[13.882] → [31.111201:111385]

∅:D[33.2286] → [31.111201:111385]

∅:D[34.26326] → [31.111201:111385]

B:BD[31.111201] → [31.111201:111385]

∅:D[31.111385] → [37.4896:4915]

B:BD[37.4896] → [37.4896:4915]

∅:D[33.2610] → [31.111760:111800]

∅:D[35.8928] → [31.111760:111800]

∅:D[34.26689] → [31.111760:111800]

B:BD[31.111760] → [31.111760:111800]

∅:D[33.2495] → [35.8742:8787]

∅:D[34.26561] → [35.8742:8787]

B:BD[35.8742] → [35.8742:8787]

B:BD[35.8787] → [33.2496:2610]

∅:D[31.111800] → [36.410:558]

B:BD[37.5378] → [36.410:558]

∅:D[36.558] → [37.5378:5746]

B:BD[37.5378] → [37.5378:5746]

B:BD[37.4915] → [33.2287:2495]

B:BD[31.111061] → [13.752:882]

∅:D[39.6647] → [31.110773:110830]

∅:D[34.26192] → [31.110773:110830]

B:BD[31.110773] → [31.110773:110830]

∅:D[40.8835] → [31.110830:110875]

B:BD[31.110830] → [31.110830:110875]

B:BD[31.110875] → [30.9806:9832]

B:BD[31.110830] → [40.8803:8835]

B:BD[37.4277] → [39.6503:6647]

B:BD[37.3909] → [31.110547:110665]

B:BD[37.3761] → [33.2066:2165]

B:BD[37.3500] → [39.6358:6502]

B:BD[37.3277] → [51.15:188]

∅:D[30.9778] → [31.109461:109628]

B:BD[32.1402] → [31.109461:109628]

∅:D[13.751] → [31.109759:109925]

∅:D[33.1845] → [31.109759:109925]

∅:D[34.25437] → [31.109759:109925]

B:BD[31.109759] → [31.109759:109925]

∅:D[31.109925] → [51.763:789]

B:BD[51.763] → [51.763:789]

∅:D[33.1953] → [51.869:881]

∅:D[35.8370] → [51.869:881]

∅:D[34.25558] → [51.869:881]

∅:D[31.110045] → [51.869:881]

B:BD[51.869] → [51.869:881]

∅:D[33.2065] → [31.110169:110209]

∅:D[35.8559] → [31.110169:110209]

∅:D[34.25683] → [31.110169:110209]

B:BD[31.110169] → [31.110169:110209]

∅:D[31.110209] → [51.1027:1092]

B:BD[51.1027] → [51.1027:1092]

B:BD[51.881] → [35.8371:8421]

B:BD[35.8421] → [33.1954:2065]

B:BD[51.789] → [33.1846:1953]

B:BD[31.109628] → [13.630:751]

∅:D[12.81] → [31.109358:109415]

∅:D[39.6357] → [31.109358:109415]

∅:D[34.25312] → [31.109358:109415]

B:BD[31.109358] → [31.109358:109415]

∅:D[40.8769] → [31.109415:109460]

B:BD[31.109415] → [31.109415:109460]

B:BD[31.109460] → [30.9752:9778]

B:BD[31.109415] → [40.8737:8769]

B:BD[31.109251] → [39.6213:6357]

B:BD[39.6357] → [12.49:81]

B:BD[37.2499] → [33.1410:1509]

B:BD[31.108512] → [13.510:629]

∅:D[39.6212] → [31.108246:108303]

∅:D[34.24628] → [31.108246:108303]

B:BD[31.108246] → [31.108246:108303]

∅:D[40.8736] → [31.108303:108348]

B:BD[31.108303] → [31.108303:108348]

B:BD[31.108348] → [30.9725:9751]

B:BD[31.108303] → [40.8704:8736]

B:BD[37.1916] → [39.6068:6212]

B:BD[37.982] → [33.1081:1299]

B:BD[31.107537] → [13.381:509]

∅:D[39.6067] → [31.107248:107305]

∅:D[34.24053] → [31.107248:107305]

B:BD[31.107248] → [31.107248:107305]

∅:D[40.8703] → [31.107305:107355]

B:BD[31.107305] → [31.107305:107355]

B:BD[31.107355] → [30.9698:9724]

B:BD[31.107305] → [40.8671:8703]

B:BD[37.313] → [39.5923:6067]

B:BD[28.924] → [33.743:961]

B:BD[31.106470] → [13.263:380]

∅:D[12.48] → [31.106208:106265]

∅:D[39.5922] → [31.106208:106265]

∅:D[34.23489] → [31.106208:106265]

B:BD[31.106208] → [31.106208:106265]

∅:D[40.8637] → [31.106265:106310]

B:BD[31.106265] → [31.106265:106310]

B:BD[31.106310] → [30.9671:9697]

B:BD[31.106265] → [40.8605:8637]

B:BD[31.106101] → [39.5778:5922]

B:BD[39.5922] → [12.16:48]

B:BD[28.193] → [29.63:186]

∅:D[32.1342] → [29.241:280]

∅:D[30.9670] → [29.241:280]

B:BD[29.241] → [29.241:280]

∅:D[35.7364] → [48.789:821]

∅:D[34.23291] → [48.789:821]

∅:D[31.106068] → [48.789:821]

B:BD[29.327] → [48.789:821]

∅:D[46.50] → [48.840:963]

B:BD[48.840] → [48.840:963]

∅:D[46.82] → [29.327:481]

∅:D[48.979] → [29.327:481]

B:BD[29.327] → [29.327:481]

B:BD[48.963] → [46.51:82]

B:BD[48.821] → [46.16:50]

B:BD[29.280] → [34.23223:23291]

∅:D[39.5777] → [31.105939:106007]

∅:D[34.23222] → [31.105939:106007]

B:BD[29.186] → [31.105939:106007]

∅:D[40.8604] → [30.9644:9670]

B:BD[31.106007] → [30.9644:9670]

B:BD[31.106007] → [40.8572:8604]

B:BD[29.186] → [39.5731:5777]

-- major tests for drawings
-- We minimize assumptions about specific pixels, and try to test at the level
-- of specific shapes. In particular, no tests of freehand drawings.
function test_draw_line()
  io.write('\ntest_draw_line')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  check_eq(#Editor_state.lines, 2, 'F - test_draw_line/baseline/#lines')
  check_eq(Editor_state.lines[1].mode, 'drawing', 'F - test_draw_line/baseline/mode')
  check_eq(Editor_state.lines[1].h, 128, 'F - test_draw_line/baseline/y')
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_draw_line/baseline/#shapes')
  -- draw a line
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_draw_line/#shapes')
  check_eq(#drawing.points, 2, 'F - test_draw_line/#points')
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_draw_line/shape:1')
  local p1 = drawing.points[drawing.shapes[1].p1]
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p1.x, 5, 'F - test_draw_line/p1:x')
  check_eq(p1.y, 6, 'F - test_draw_line/p1:y')
  check_eq(p2.x, 35, 'F - test_draw_line/p2:x')
  check_eq(p2.y, 36, 'F - test_draw_line/p2:y')
end
function test_draw_arc()
  io.write('\ntest_draw_arc')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  check_eq(#Editor_state.lines, 2, 'F - test_draw_arc/baseline/#lines')
  check_eq(Editor_state.lines[1].mode, 'drawing', 'F - test_draw_arc/baseline/mode')
  check_eq(Editor_state.lines[1].h, 128, 'F - test_draw_arc/baseline/y')
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_draw_arc/baseline/#shapes')
  -- draw an arc
  local drawing = Editor_state.lines[1]
  edit.run_after_keychord(Editor_state, 'a')  -- arc mode
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35+50, Editor_state.top+Drawing_padding_top+36+50, 1)  -- 45°
  check_eq(#drawing.shapes, 1, 'F - test_draw_arc/#shapes')
  check_eq(drawing.shapes[1].mode, 'arc', 'F - test_draw_horizontal_line/shape_mode')
  local arc = drawing.shapes[1]
  check_eq(arc.radius, 30, 'F - test_draw_arc/radius')
  local center = drawing.points[arc.center]
  check_eq(center.x, 35, 'F - test_draw_arc/center:x')
  check_eq(center.y, 36, 'F - test_draw_arc/center:y')
  check_eq(arc.start_angle, 0, 'F - test_draw_arc/start:angle')
  check_eq(arc.end_angle, math.pi/4, 'F - test_draw_arc/end:angle')
end
function test_draw_polygon()
  io.write('\ntest_draw_polygon')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  check_eq(Editor_state.current_drawing_mode, 'line', 'F - test_draw_polygon/baseline/drawing_mode')
  check_eq(#Editor_state.lines, 2, 'F - test_draw_polygon/baseline/#lines')
  check_eq(Editor_state.lines[1].mode, 'drawing', 'F - test_draw_polygon/baseline/mode')
  check_eq(Editor_state.lines[1].h, 128, 'F - test_draw_polygon/baseline/y')
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_draw_polygon/baseline/#shapes')
  -- first point
  edit.run_after_keychord(Editor_state, 'g')  -- polygon mode
  -- second point
  edit.run_after_keychord(Editor_state, 'p')  -- add point
  -- final point
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_draw_polygon/#shapes')
  check_eq(#drawing.points, 3, 'F - test_draw_polygon/vertices')
  local shape = drawing.shapes[1]
  check_eq(shape.mode, 'polygon', 'F - test_draw_polygon/shape_mode')
  check_eq(#shape.vertices, 3, 'F - test_draw_polygon/vertices')
  local p = drawing.points[shape.vertices[1]]
  check_eq(p.x, 5, 'F - test_draw_polygon/p1:x')
  check_eq(p.y, 6, 'F - test_draw_polygon/p1:y')
  local p = drawing.points[shape.vertices[2]]
  check_eq(p.x, 65, 'F - test_draw_polygon/p2:x')
  check_eq(p.y, 36, 'F - test_draw_polygon/p2:y')
  local p = drawing.points[shape.vertices[3]]
  check_eq(p.x, 35, 'F - test_draw_polygon/p3:x')
  check_eq(p.y, 26, 'F - test_draw_polygon/p3:y')
end
function test_draw_rectangle()
  io.write('\ntest_draw_rectangle')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  check_eq(Editor_state.current_drawing_mode, 'line', 'F - test_draw_rectangle/baseline/drawing_mode')
  check_eq(#Editor_state.lines, 2, 'F - test_draw_rectangle/baseline/#lines')
  check_eq(Editor_state.lines[1].mode, 'drawing', 'F - test_draw_rectangle/baseline/mode')
  check_eq(Editor_state.lines[1].h, 128, 'F - test_draw_rectangle/baseline/y')
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_draw_rectangle/baseline/#shapes')
  -- first point
  edit.run_after_keychord(Editor_state, 'r')  -- rectangle mode
  -- second point/first edge
  edit.run_after_keychord(Editor_state, 'p')
  -- override second point/first edge
  edit.run_after_keychord(Editor_state, 'p')
  -- release (decides 'thickness' of rectangle perpendicular to first edge)
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_draw_rectangle/#shapes')
  check_eq(#drawing.points, 5, 'F - test_draw_rectangle/#points')  -- currently includes every point added
  local shape = drawing.shapes[1]
  check_eq(shape.mode, 'rectangle', 'F - test_draw_rectangle/shape_mode')
  check_eq(#shape.vertices, 4, 'F - test_draw_rectangle/vertices')
  local p = drawing.points[shape.vertices[1]]
  check_eq(p.x, 35, 'F - test_draw_rectangle/p1:x')
  check_eq(p.y, 36, 'F - test_draw_rectangle/p1:y')
  local p = drawing.points[shape.vertices[2]]
  check_eq(p.x, 75, 'F - test_draw_rectangle/p2:x')
  check_eq(p.y, 76, 'F - test_draw_rectangle/p2:y')
  local p = drawing.points[shape.vertices[3]]
  check_eq(p.x, 70, 'F - test_draw_rectangle/p3:x')
  check_eq(p.y, 81, 'F - test_draw_rectangle/p3:y')
  local p = drawing.points[shape.vertices[4]]
  check_eq(p.x, 30, 'F - test_draw_rectangle/p4:x')
  check_eq(p.y, 41, 'F - test_draw_rectangle/p4:y')
end
function test_draw_rectangle_intermediate()
  io.write('\ntest_draw_rectangle_intermediate')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  check_eq(Editor_state.current_drawing_mode, 'line', 'F - test_draw_rectangle_intermediate/baseline/drawing_mode')
  check_eq(#Editor_state.lines, 2, 'F - test_draw_rectangle_intermediate/baseline/#lines')
  check_eq(Editor_state.lines[1].mode, 'drawing', 'F - test_draw_rectangle_intermediate/baseline/mode')
  check_eq(Editor_state.lines[1].h, 128, 'F - test_draw_rectangle_intermediate/baseline/y')
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_draw_rectangle_intermediate/baseline/#shapes')
  -- first point
  edit.run_after_keychord(Editor_state, 'r')  -- rectangle mode
  -- second point/first edge
  edit.run_after_keychord(Editor_state, 'p')
  -- override second point/first edge
  local drawing = Editor_state.lines[1]
  edit.run_after_keychord(Editor_state, 'p')
  check_eq(#drawing.points, 3, 'F - test_draw_rectangle_intermediate/#points')  -- currently includes every point added
  local pending = drawing.pending
  check_eq(pending.mode, 'rectangle', 'F - test_draw_rectangle_intermediate/shape_mode')
  check_eq(#pending.vertices, 2, 'F - test_draw_rectangle_intermediate/vertices')
  local p = drawing.points[pending.vertices[1]]
  check_eq(p.x, 35, 'F - test_draw_rectangle_intermediate/p1:x')
  check_eq(p.y, 36, 'F - test_draw_rectangle_intermediate/p1:y')
  local p = drawing.points[pending.vertices[2]]
  check_eq(p.x, 75, 'F - test_draw_rectangle_intermediate/p2:x')
  check_eq(p.y, 76, 'F - test_draw_rectangle_intermediate/p2:y')
  -- outline of rectangle is drawn based on where the mouse is, but we can't check that so far
end
function test_draw_square()
  io.write('\ntest_draw_square')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  check_eq(Editor_state.current_drawing_mode, 'line', 'F - test_draw_square/baseline/drawing_mode')
  check_eq(#Editor_state.lines, 2, 'F - test_draw_square/baseline/#lines')
  check_eq(Editor_state.lines[1].mode, 'drawing', 'F - test_draw_square/baseline/mode')
  check_eq(Editor_state.lines[1].h, 128, 'F - test_draw_square/baseline/y')
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_draw_square/baseline/#shapes')
  -- first point
  edit.run_after_keychord(Editor_state, 's')  -- square mode
  -- second point/first edge
  edit.run_after_keychord(Editor_state, 'p')
  -- override second point/first edge
  edit.run_after_keychord(Editor_state, 'p')
  -- release (decides which side of first edge to draw square on)
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_draw_square/#shapes')
  check_eq(#drawing.points, 5, 'F - test_draw_square/#points')  -- currently includes every point added
  check_eq(drawing.shapes[1].mode, 'square', 'F - test_draw_square/shape_mode')
  check_eq(#drawing.shapes[1].vertices, 4, 'F - test_draw_square/vertices')
  local p = drawing.points[drawing.shapes[1].vertices[1]]
  check_eq(p.x, 35, 'F - test_draw_square/p1:x')
  check_eq(p.y, 36, 'F - test_draw_square/p1:y')
  local p = drawing.points[drawing.shapes[1].vertices[2]]
  check_eq(p.x, 65, 'F - test_draw_square/p2:x')
  check_eq(p.y, 66, 'F - test_draw_square/p2:y')
  local p = drawing.points[drawing.shapes[1].vertices[3]]
  check_eq(p.x, 35, 'F - test_draw_square/p3:x')
  check_eq(p.y, 96, 'F - test_draw_square/p3:y')
  local p = drawing.points[drawing.shapes[1].vertices[4]]
  check_eq(p.x, 5, 'F - test_draw_square/p4:x')
  check_eq(p.y, 66, 'F - test_draw_square/p4:y')
end
function test_name_point()
  io.write('\ntest_name_point')
  -- create a drawing with a line
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  Editor_state.filename = 'foo'
  -- draw a line
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_name_point/baseline/#shapes')
  check_eq(#drawing.points, 2, 'F - test_name_point/baseline/#points')
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_name_point/baseline/shape:1')
  local p1 = drawing.points[drawing.shapes[1].p1]
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p1.x, 5, 'F - test_name_point/baseline/p1:x')
  check_eq(p1.y, 6, 'F - test_name_point/baseline/p1:y')
  check_eq(p2.x, 35, 'F - test_name_point/baseline/p2:x')
  check_eq(p2.y, 36, 'F - test_name_point/baseline/p2:y')
  check_nil(p2.name, 'F - test_name_point/baseline/p2:name')
  -- enter 'name' mode without moving the mouse
  check_eq(Editor_state.current_drawing_mode, 'name', 'F - test_name_point/mode:1')
  check_eq(p2.name, 'A', 'F - test_name_point')
  -- still in 'name' mode
  -- exit 'name' mode
  check_eq(Editor_state.current_drawing_mode, 'line', 'F - test_name_point/mode:3')
  check_eq(p2.name, 'A', 'F - test_name_point')
end
function test_delete_point_from_polygon()
  io.write('\ntest_delete_point_from_polygon')
  -- create a drawing with two lines connected at a point
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  -- first point
  edit.run_after_keychord(Editor_state, 'g')  -- polygon mode
  -- second point
  edit.run_after_keychord(Editor_state, 'p')  -- add point
  -- third point
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_delete_point_from_polygon/baseline/#shapes')
  check_eq(drawing.shapes[1].mode, 'polygon', 'F - test_delete_point_from_polygon/baseline/mode')
  check_eq(#drawing.shapes[1].vertices, 3, 'F - test_delete_point_from_polygon/baseline/vertices')
  -- hover on a point and delete
  edit.run_after_keychord(Editor_state, 'C-d')
  -- there's < 3 points left, so the whole polygon is deleted
  check_eq(drawing.shapes[1].mode, 'deleted', 'F - test_delete_point_from_polygon')
end
function test_undo_name_point()
  io.write('\ntest_undo_name_point')
  -- create a drawing with a line
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  Editor_state.filename = 'foo'
  -- draw a line
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_undo_name_point/baseline/#shapes')
  check_eq(#drawing.points, 2, 'F - test_undo_name_point/baseline/#points')
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_undo_name_point/baseline/shape:1')
  local p1 = drawing.points[drawing.shapes[1].p1]
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p1.x, 5, 'F - test_undo_name_point/baseline/p1:x')
  check_eq(p1.y, 6, 'F - test_undo_name_point/baseline/p1:y')
  check_eq(p2.x, 35, 'F - test_undo_name_point/baseline/p2:x')
  check_eq(p2.y, 36, 'F - test_undo_name_point/baseline/p2:y')
  check_nil(p2.name, 'F - test_undo_name_point/baseline/p2:name')
  -- enter 'name' mode without moving the mouse
  check_eq(p2.name, 'A', 'F - test_undo_name_point/baseline')
  -- undo
  local drawing = Editor_state.lines[1]
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p2.name, '', 'F - test_undo_name_point')  -- not quite what it was before, but close enough
  check_eq(p2.name, '', 'F - test_undo_name_point/save')
end
function test_undo_move_point()
  io.write('\ntest_undo_move_point')
  -- create a drawing with a line
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_undo_move_point/baseline/#shapes')
  check_eq(#drawing.points, 2, 'F - test_undo_move_point/baseline/#points')
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_undo_move_point/baseline/shape:1')
  local p1 = drawing.points[drawing.shapes[1].p1]
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p1.x, 5, 'F - test_undo_move_point/baseline/p1:x')
  check_eq(p1.y, 6, 'F - test_undo_move_point/baseline/p1:y')
  check_eq(p2.x, 35, 'F - test_undo_move_point/baseline/p2:x')
  check_eq(p2.y, 36, 'F - test_undo_move_point/baseline/p2:y')
  check_nil(p2.name, 'F - test_undo_move_point/baseline/p2:name')
  -- move p2
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p2.x, 26, 'F - test_undo_move_point/x')
  check_eq(p2.y, 44, 'F - test_undo_move_point/y')
  -- exit 'move' mode
  check_eq(Editor_state.next_history, 4, 'F - test_undo_move_point/next_history')
  -- undo
  local drawing = Editor_state.lines[1]
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p2.x, 35, 'F - test_undo_move_point/x')
  check_eq(p2.y, 36, 'F - test_undo_move_point/y')
  check_eq(p2.x, 35, 'F - test_undo_move_point/save/x')
  check_eq(p2.y, 36, 'F - test_undo_move_point/save/y')
end
end
function test_undo_delete_point()
  io.write('\ntest_undo_delete_point')
  -- create a drawing with two lines connected at a point
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 2, 'F - test_undo_delete_point/baseline/#shapes')
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_undo_delete_point/baseline/shape:1')
  check_eq(drawing.shapes[2].mode, 'line', 'F - test_undo_delete_point/baseline/shape:2')
  -- hover on the common point and delete
  edit.run_after_keychord(Editor_state, 'C-d')
  check_eq(drawing.shapes[1].mode, 'deleted', 'F - test_undo_delete_point/shape:1')
  check_eq(drawing.shapes[2].mode, 'deleted', 'F - test_undo_delete_point/shape:2')
  -- undo
  local drawing = Editor_state.lines[1]
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_undo_delete_point/shape:1')
  check_eq(drawing.shapes[2].mode, 'line', 'F - test_undo_delete_point/shape:2')
  -- undo is saved
  Text.redraw_all(Editor_state)
  check_eq(#Editor_state.lines[1].shapes, 2, 'F - test_undo_delete_point/save')
  load_from_disk(Editor_state)
  -- wait until save
  App.wait_fake_time(3.1)
  edit.update(Editor_state, 0)
  check_eq(Editor_state.next_history, 3, 'F - test_undo_move_point/next_history')
  edit.run_after_keychord(Editor_state, 'C-z')
  App.mouse_move(Editor_state.left+35, Editor_state.top+Drawing_padding_top+36)
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+55, Editor_state.top+Drawing_padding_top+26, 1)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  Editor_state.filename = 'foo'
  -- wait until save
  App.wait_fake_time(3.1)
  edit.update(Editor_state, 0)
  -- undo is saved
  Text.redraw_all(Editor_state)
  local p2 = Editor_state.lines[1].points[drawing.shapes[1].p2]
  load_from_disk(Editor_state)
  check_eq(Editor_state.next_history, 2, 'F - test_undo_move_point/next_history')
  edit.run_after_keychord(Editor_state, 'C-z')
  edit.run_after_keychord(Editor_state, 'C-z')  -- bug: need to undo twice
  edit.run_after_mouse_click(Editor_state, Editor_state.left+26, Editor_state.top+Drawing_padding_top+44, 1)
  edit.run_after_keychord(Editor_state, 'C-u')
  edit.update(Editor_state, 0.05)
  App.mouse_move(Editor_state.left+26, Editor_state.top+Drawing_padding_top+44)
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  Editor_state.filename = 'foo'
  -- wait until save
  App.wait_fake_time(3.1)
  edit.update(Editor_state, 0)
  -- undo is saved
  Text.redraw_all(Editor_state)
  local p2 = Editor_state.lines[1].points[drawing.shapes[1].p2]
  load_from_disk(Editor_state)
  check_eq(Editor_state.next_history, 3, 'F - test_undo_name_point/next_history')
  edit.run_after_keychord(Editor_state, 'C-z')
  check_eq(#Editor_state.history, 3, 'F - test_undo_name_point/baseline/history:2')
  check_eq(Editor_state.next_history, 4, 'F - test_undo_name_point/baseline/next_history')
--?   print('b', Editor_state.lines.current_drawing)
  edit.run_after_keychord(Editor_state, 'C-n')
  edit.run_after_textinput(Editor_state, 'A')
  edit.run_after_keychord(Editor_state, 'return')
  check_eq(#Editor_state.history, 1, 'F - test_undo_name_point/baseline/history:1')
--?   print('a', Editor_state.lines.current_drawing)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  App.mouse_move(Editor_state.left+65, Editor_state.top+Drawing_padding_top+36)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+14, Editor_state.top+Drawing_padding_top+16, 1)
  App.mouse_move(Editor_state.left+65, Editor_state.top+Drawing_padding_top+36)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  -- wait until save
  App.wait_fake_time(3.1)
  edit.update(Editor_state, 0)
  -- change is saved
  Text.redraw_all(Editor_state)
  local p2 = Editor_state.lines[1].points[drawing.shapes[1].p2]
  check_eq(p2.name, 'A', 'F - test_name_point/save')
  load_from_disk(Editor_state)
end
function test_move_point()
  io.write('\ntest_move_point')
  -- create a drawing with a line
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_move_point/baseline/#shapes')
  check_eq(#drawing.points, 2, 'F - test_move_point/baseline/#points')
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_move_point/baseline/shape:1')
  local p1 = drawing.points[drawing.shapes[1].p1]
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p1.x, 5, 'F - test_move_point/baseline/p1:x')
  check_eq(p1.y, 6, 'F - test_move_point/baseline/p1:y')
  check_eq(p2.x, 35, 'F - test_move_point/baseline/p2:x')
  check_eq(p2.y, 36, 'F - test_move_point/baseline/p2:y')
  -- wait until save
  App.wait_fake_time(3.1)
  -- line is saved to disk
  Text.redraw_all(Editor_state)
  local drawing = Editor_state.lines[1]
  local p2 = Editor_state.lines[1].points[drawing.shapes[1].p2]
  check_eq(p2.x, 35, 'F - test_move_point/save/x')
  check_eq(p2.y, 36, 'F - test_move_point/save/y')
  -- enter 'move' mode without moving the mouse
  check_eq(Editor_state.current_drawing_mode, 'move', 'F - test_move_point/mode:1')
  -- point is lifted
  check_eq(drawing.pending.mode, 'move', 'F - test_move_point/mode:2')
  check_eq(drawing.pending.target_point, p2, 'F - test_move_point/target')
  -- move point
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p2.x, 26, 'F - test_move_point/x')
  check_eq(p2.y, 44, 'F - test_move_point/y')
  -- exit 'move' mode
  check_eq(Editor_state.current_drawing_mode, 'line', 'F - test_move_point/mode:3')
  check_eq(drawing.pending, {}, 'F - test_move_point/pending')
  -- wait until save
  App.wait_fake_time(3.1)
  edit.update(Editor_state, 0)
  -- change is saved
  Text.redraw_all(Editor_state)
  local p2 = Editor_state.lines[1].points[drawing.shapes[1].p2]
  check_eq(p2.x, 26, 'F - test_move_point/save/x')
  check_eq(p2.y, 44, 'F - test_move_point/save/y')
  load_from_disk(Editor_state)
end
function test_delete_lines_at_point()
  io.write('\ntest_delete_lines_at_point')
  -- create a drawing with two lines connected at a point
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 2, 'F - test_delete_lines_at_point/baseline/#shapes')
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_delete_lines_at_point/baseline/shape:1')
  check_eq(drawing.shapes[2].mode, 'line', 'F - test_delete_lines_at_point/baseline/shape:2')
  -- hover on the common point and delete
  edit.run_after_keychord(Editor_state, 'C-d')
  check_eq(drawing.shapes[1].mode, 'deleted', 'F - test_delete_lines_at_point/shape:1')
  check_eq(drawing.shapes[2].mode, 'deleted', 'F - test_delete_lines_at_point/shape:2')
end
function test_delete_line_under_mouse_pointer()
  io.write('\ntest_delete_line_under_mouse_pointer')
  -- create a drawing with two lines connected at a point
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 2, 'F - test_delete_line_under_mouse_pointer/baseline/#shapes')
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_delete_line_under_mouse_pointer/baseline/shape:1')
  check_eq(drawing.shapes[2].mode, 'line', 'F - test_delete_line_under_mouse_pointer/baseline/shape:2')
  -- hover on one of the lines and delete
  edit.run_after_keychord(Editor_state, 'C-d')
  -- only that line is deleted
  check_eq(drawing.shapes[1].mode, 'deleted', 'F - test_delete_line_under_mouse_pointer/shape:1')
  check_eq(drawing.shapes[2].mode, 'line', 'F - test_delete_line_under_mouse_pointer/shape:2')
end
function test_delete_point_from_polygon()
  io.write('\ntest_delete_point_from_polygon')
  -- create a drawing with two lines connected at a point
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  -- first point
  edit.run_after_keychord(Editor_state, 'g')  -- polygon mode
  -- second point
  edit.run_after_keychord(Editor_state, 'p')  -- add point
  -- third point
  edit.run_after_keychord(Editor_state, 'p')  -- add point
  -- fourth point
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_delete_point_from_polygon/baseline/#shapes')
  check_eq(drawing.shapes[1].mode, 'polygon', 'F - test_delete_point_from_polygon/baseline/mode')
  check_eq(#drawing.shapes[1].vertices, 4, 'F - test_delete_point_from_polygon/baseline/vertices')
  -- hover on a point and delete
  edit.run_after_keychord(Editor_state, 'C-d')
  -- just the one point is deleted
  check_eq(drawing.shapes[1].mode, 'polygon', 'F - test_delete_point_from_polygon/shape')
  check_eq(#drawing.shapes[1].vertices, 3, 'F - test_delete_point_from_polygon/vertices')
  App.mouse_move(Editor_state.left+35, Editor_state.top+Drawing_padding_top+26)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+14, Editor_state.top+Drawing_padding_top+16, 1)
  App.mouse_move(Editor_state.left+35, Editor_state.top+Drawing_padding_top+26)
  App.mouse_move(Editor_state.left+65, Editor_state.top+Drawing_padding_top+36)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  App.mouse_move(Editor_state.left+25, Editor_state.top+Drawing_padding_top+26)
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+55, Editor_state.top+Drawing_padding_top+26, 1)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  -- wait for some time
  App.wait_fake_time(3.1)
  edit.update(Editor_state, 0)
  -- deleted points disappear after file is reloaded
  Text.redraw_all(Editor_state)
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_delete_lines_at_point/save')
  load_from_disk(Editor_state)
  App.mouse_move(Editor_state.left+35, Editor_state.top+Drawing_padding_top+36)
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+55, Editor_state.top+Drawing_padding_top+26, 1)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  Editor_state.filename = 'foo'
function test_move_point_on_manhattan_line()
  io.write('\ntest_move_point_on_manhattan_line')
  -- create a drawing with a manhattan line
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_move_point_on_manhattan_line/baseline/#shapes')
  check_eq(#drawing.points, 2, 'F - test_move_point_on_manhattan_line/baseline/#points')
  check_eq(drawing.shapes[1].mode, 'manhattan', 'F - test_move_point_on_manhattan_line/baseline/shape:1')
  -- enter 'move' mode
  check_eq(Editor_state.current_drawing_mode, 'move', 'F - test_move_point_on_manhattan_line/mode:1')
  -- move point
  -- line is no longer manhattan
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_move_point_on_manhattan_line/baseline/shape:1')
end
  edit.update(Editor_state, 0.05)
  App.mouse_move(Editor_state.left+26, Editor_state.top+Drawing_padding_top+44)
  edit.run_after_keychord(Editor_state, 'C-u')
  edit.draw(Editor_state)
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'manhattan'
  edit.draw(Editor_state)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+46, 1)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  Editor_state.filename = 'foo'
  edit.run_after_mouse_click(Editor_state, Editor_state.left+26, Editor_state.top+Drawing_padding_top+44, 1)
  edit.update(Editor_state, 0.05)
  App.mouse_move(Editor_state.left+26, Editor_state.top+Drawing_padding_top+44)
  edit.run_after_keychord(Editor_state, 'C-u')
  edit.draw(Editor_state)
  load_from_disk(Editor_state)
  edit.update(Editor_state, 0)
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  Editor_state.filename = 'foo'
  edit.run_after_keychord(Editor_state, 'return')
  check_eq(Editor_state.current_drawing_mode, 'name', 'F - test_name_point/mode:2')
  edit.run_after_textinput(Editor_state, 'A')
  edit.run_after_keychord(Editor_state, 'C-n')
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+15, Editor_state.top+Drawing_padding_top+26, 1)
  App.mouse_move(Editor_state.left+65, Editor_state.top+Drawing_padding_top+66)
  App.mouse_move(Editor_state.left+42, Editor_state.top+Drawing_padding_top+45)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  check_eq(Editor_state.line_cache[1].starty, Editor_state.top+Drawing_padding_top, 'F - test_draw_square/baseline/y')
  Editor_state.lines = load_array{'```lines', '```', ''}
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  App.mouse_move(Editor_state.left+75, Editor_state.top+Drawing_padding_top+76)
  App.mouse_move(Editor_state.left+42, Editor_state.top+Drawing_padding_top+45)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  check_eq(Editor_state.line_cache[1].starty, Editor_state.top+Drawing_padding_top, 'F - test_draw_rectangle_intermediate/baseline/y')
  Editor_state.lines = load_array{'```lines', '```', ''}
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  edit.run_after_mouse_release(Editor_state, Editor_state.left+15, Editor_state.top+Drawing_padding_top+26, 1)
  App.mouse_move(Editor_state.left+75, Editor_state.top+Drawing_padding_top+76)
  App.mouse_move(Editor_state.left+42, Editor_state.top+Drawing_padding_top+45)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  check_eq(Editor_state.line_cache[1].starty, Editor_state.top+Drawing_padding_top, 'F - test_draw_rectangle/baseline/y')
  Editor_state.lines = load_array{'```lines', '```', ''}
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+26, 1)
  App.mouse_move(Editor_state.left+65, Editor_state.top+Drawing_padding_top+36)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  check_eq(Editor_state.line_cache[1].starty, Editor_state.top+Drawing_padding_top, 'F - test_draw_polygon/baseline/y')
  Editor_state.lines = load_array{'```lines', '```', ''}
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  check_eq(#drawing.points, 1, 'F - test_draw_arc/#points')
  edit.run_after_mouse_press(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  App.mouse_move(Editor_state.left+35+30, Editor_state.top+Drawing_padding_top+36)
  check_eq(Editor_state.line_cache[1].starty, Editor_state.top+Drawing_padding_top, 'F - test_draw_arc/baseline/y')
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'circle'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  -- wait until save
  App.wait_fake_time(3.1)
  edit.update(Editor_state, 0)
  -- The format on disk isn't perfectly stable. Table fields can be reordered.
  -- So just reload from disk to verify.
  Text.redraw_all(Editor_state)
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_draw_line/save/#shapes')
  check_eq(#drawing.points, 2, 'F - test_draw_line/save/#points')
  check_eq(drawing.shapes[1].mode, 'line', 'F - test_draw_line/save/shape:1')
  local p1 = drawing.points[drawing.shapes[1].p1]
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p1.x, 5, 'F - test_draw_line/save/p1:x')
  check_eq(p1.y, 6, 'F - test_draw_line/save/p1:y')
  check_eq(p2.x, 35, 'F - test_draw_line/save/p2:x')
  check_eq(p2.y, 36, 'F - test_draw_line/save/p2:y')
  load_from_disk(Editor_state)
end
function test_draw_horizontal_line()
  io.write('\ntest_draw_horizontal_line')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  check_eq(#Editor_state.lines, 2, 'F - test_draw_horizontal_line/baseline/#lines')
  check_eq(Editor_state.lines[1].mode, 'drawing', 'F - test_draw_horizontal_line/baseline/mode')
  check_eq(Editor_state.lines[1].h, 128, 'F - test_draw_horizontal_line/baseline/y')
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_draw_horizontal_line/baseline/#shapes')
  -- draw a line that is more horizontal than vertical
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 1, 'F - test_draw_horizontal_line/#shapes')
  check_eq(#drawing.points, 2, 'F - test_draw_horizontal_line/#points')
  check_eq(drawing.shapes[1].mode, 'manhattan', 'F - test_draw_horizontal_line/shape_mode')
  local p1 = drawing.points[drawing.shapes[1].p1]
  local p2 = drawing.points[drawing.shapes[1].p2]
  check_eq(p1.x, 5, 'F - test_draw_horizontal_line/p1:x')
  check_eq(p1.y, 6, 'F - test_draw_horizontal_line/p1:y')
  check_eq(p2.x, 35, 'F - test_draw_horizontal_line/p2:x')
  check_eq(p2.y, p1.y, 'F - test_draw_horizontal_line/p2:y')
end
function test_draw_circle()
  io.write('\ntest_draw_circle')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  check_eq(#Editor_state.lines, 2, 'F - test_draw_circle/baseline/#lines')
  check_eq(Editor_state.lines[1].mode, 'drawing', 'F - test_draw_circle/baseline/mode')
  check_eq(Editor_state.lines[1].h, 128, 'F - test_draw_circle/baseline/y')
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_draw_circle/baseline/#shapes')
  -- draw a circle
  local drawing = Editor_state.lines[1]
  edit.run_after_keychord(Editor_state, 'C-o')
  edit.run_after_mouse_press(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35+30, Editor_state.top+Drawing_padding_top+36, 1)
  check_eq(#drawing.shapes, 1, 'F - test_draw_circle/#shapes')
  check_eq(#drawing.points, 1, 'F - test_draw_circle/#points')
  check_eq(drawing.shapes[1].mode, 'circle', 'F - test_draw_horizontal_line/shape_mode')
  check_eq(drawing.shapes[1].radius, 30, 'F - test_draw_circle/radius')
  local center = drawing.points[drawing.shapes[1].center]
  check_eq(center.x, 35, 'F - test_draw_circle/center:x')
  check_eq(center.y, 36, 'F - test_draw_circle/center:y')
end
function test_keys_do_not_affect_shape_when_mouse_up()
  io.write('\ntest_keys_do_not_affect_shape_when_mouse_up')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  -- hover over drawing and press 'o' without holding mouse
  edit.run_after_keychord(Editor_state, 'o')
  -- no change to drawing mode
  -- no change to text either because we didn't run the textinput event
end
function test_draw_circle_mid_stroke()
  io.write('\ntest_draw_circle_mid_stroke')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  check_eq(#Editor_state.lines, 2, 'F - test_draw_circle_mid_stroke/baseline/#lines')
  check_eq(Editor_state.lines[1].mode, 'drawing', 'F - test_draw_circle_mid_stroke/baseline/mode')
  check_eq(Editor_state.lines[1].h, 128, 'F - test_draw_circle_mid_stroke/baseline/y')
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_draw_circle_mid_stroke/baseline/#shapes')
  -- draw a circle
  local drawing = Editor_state.lines[1]
  edit.run_after_keychord(Editor_state, 'o')
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35+30, Editor_state.top+Drawing_padding_top+36, 1)
  check_eq(#drawing.shapes, 1, 'F - test_draw_circle_mid_stroke/#shapes')
  check_eq(#drawing.points, 1, 'F - test_draw_circle_mid_stroke/#points')
  check_eq(drawing.shapes[1].mode, 'circle', 'F - test_draw_horizontal_line/shape_mode')
  check_eq(drawing.shapes[1].radius, 30, 'F - test_draw_circle_mid_stroke/radius')
  local center = drawing.points[drawing.shapes[1].center]
  check_eq(center.x, 35, 'F - test_draw_circle_mid_stroke/center:x')
  check_eq(center.y, 36, 'F - test_draw_circle_mid_stroke/center:y')
  App.mouse_move(Editor_state.left+4, Editor_state.top+Drawing_padding_top+4)  -- hover on drawing
  edit.run_after_mouse_press(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  check_eq(Editor_state.line_cache[1].starty, Editor_state.top+Drawing_padding_top, 'F - test_draw_circle_mid_stroke/baseline/y')
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  check_eq(Editor_state.current_drawing_mode, 'line', 'F - test_keys_do_not_affect_shape_when_mouse_up/drawing_mode')
  App.mouse_move(Editor_state.left+4, Editor_state.top+Drawing_padding_top+4)  -- hover on drawing
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
end
function test_cancel_stroke()
  io.write('\ntest_cancel_stroke')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  check_eq(#Editor_state.lines, 2, 'F - test_cancel_stroke/baseline/#lines')
  check_eq(Editor_state.lines[1].mode, 'drawing', 'F - test_cancel_stroke/baseline/mode')
  check_eq(Editor_state.lines[1].h, 128, 'F - test_cancel_stroke/baseline/y')
  check_eq(#Editor_state.lines[1].shapes, 0, 'F - test_cancel_stroke/baseline/#shapes')
  -- start drawing a line
  -- cancel
  local drawing = Editor_state.lines[1]
  check_eq(#drawing.shapes, 0, 'F - test_cancel_stroke/#shapes')
  edit.run_after_keychord(Editor_state, 'escape')
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  check_eq(Editor_state.line_cache[1].starty, Editor_state.top+Drawing_padding_top, 'F - test_cancel_stroke/baseline/y')
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  Editor_state.filename = 'foo'
  App.mouse_move(Editor_state.left+4, Editor_state.top+Drawing_padding_top+4)  -- hover on drawing
  check_eq(Editor_state.line_cache[1].starty, Editor_state.top+Drawing_padding_top, 'F - test_draw_circle/baseline/y')
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+26, 1)
  check_eq(Editor_state.line_cache[1].starty, Editor_state.top+Drawing_padding_top, 'F - test_draw_horizontal_line/baseline/y')
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'manhattan'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  edit.run_after_mouse_press(Editor_state, Editor_state.left+5, Editor_state.top+Drawing_padding_top+6, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+35, Editor_state.top+Drawing_padding_top+36, 1)
  check_eq(Editor_state.line_cache[1].starty, Editor_state.top+Drawing_padding_top, 'F - test_draw_line/baseline/y')
  Editor_state.lines = load_array{'```lines', '```', ''}
  Editor_state.current_drawing_mode = 'line'
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  App.screen.init{width=Test_margin_left+256, height=300}  -- drawing coordinates 1:1 with pixels
  Editor_state = edit.initialize_test_state()
  Editor_state.filename = 'foo'
function test_creating_drawing_saves()
  io.write('\ntest_creating_drawing_saves')
  App.screen.init{width=120, height=60}
  -- click on button to create drawing
  -- file not immediately saved
  check_nil(App.filesystem['foo'], 'F - test_creating_drawing_saves/early')
  -- wait until save
  App.wait_fake_time(3.1)
  -- filesystem contains drawing and an empty line of text
  check_eq(App.filesystem['foo'], '```lines\n```\n\n', 'F - test_creating_drawing_saves')
end
  edit.update(Editor_state, 0)
  edit.update(Editor_state, 0.01)
  edit.run_after_mouse_click(Editor_state, 8,Editor_state.top+8, 1)
  Editor_state.filename = 'foo'
  Editor_state.lines = load_array{}
  edit.draw(Editor_state)
  Text.redraw_all(Editor_state)
  Editor_state = edit.initialize_test_state()

File deletion: drawing.lua

BF:BFD[27.2] → [52.1542:1577]

BF:BFD[52.1577] → [52.98:98]

B:BD[52.98] → [52.99:147]

B:BD[28.1578] → [28.1578:1602]

∅:D[53.569] → [52.147:148]

∅:D[28.1602] → [52.147:148]

∅:D[54.18268] → [52.147:148]

B:BD[52.147] → [52.147:148]

∅:D[55.85] → [52.523:532]

∅:D[56.452] → [52.523:532]

∅:D[57.548] → [52.523:532]

∅:D[58.1872] → [52.523:532]

∅:D[13.1972] → [52.523:532]

∅:D[59.2927] → [52.523:532]

∅:D[60.4395] → [52.523:532]

∅:D[61.6863] → [52.523:532]

∅:D[54.18548] → [52.523:532]

∅:D[34.36888] → [52.523:532]

∅:D[31.127573] → [52.523:532]

B:BD[52.523] → [52.523:532]

∅:D[55.157] → [52.589:598]

∅:D[56.543] → [52.589:598]

∅:D[57.611] → [52.589:598]

∅:D[58.1932] → [52.589:598]

∅:D[13.2050] → [52.589:598]

∅:D[59.2999] → [52.589:598]

∅:D[60.4461] → [52.589:598]

∅:D[61.6942] → [52.589:598]

∅:D[54.18614] → [52.589:598]

∅:D[34.36955] → [52.589:598]

∅:D[31.127678] → [52.589:598]

B:BD[52.589] → [52.589:598]

∅:D[14.756] → [52.704:757]

∅:D[62.6737] → [52.704:757]

B:BD[52.704] → [52.704:757]

∅:D[14.812] → [52.799:817]

∅:D[62.6787] → [52.799:817]

B:BD[52.799] → [52.799:817]

∅:D[63.75] → [52.894:953]

∅:D[64.116] → [52.894:953]

∅:D[65.125] → [52.894:953]

∅:D[56.624] → [52.894:953]

∅:D[13.2114] → [52.894:953]

∅:D[59.3074] → [52.894:953]

∅:D[54.18708] → [52.894:953]

∅:D[34.37029] → [52.894:953]

∅:D[31.127766] → [52.894:953]

B:BD[52.894] → [52.894:953]

∅:D[66.1089] → [52.1030:1039]

B:BD[52.1030] → [52.1030:1039]

∅:D[66.1120] → [52.1075:1083]

B:BD[52.1075] → [52.1075:1083]

∅:D[56.687] → [52.1122:1128]

∅:D[67.1029] → [52.1122:1128]

∅:D[13.2194] → [52.1122:1128]

∅:D[59.3131] → [52.1122:1128]

∅:D[54.18803] → [52.1122:1128]

∅:D[34.37085] → [52.1122:1128]

∅:D[31.127836] → [52.1122:1128]

B:BD[52.1122] → [52.1122:1128]

∅:D[68.46] → [52.1164:1193]

B:BD[52.1164] → [52.1164:1193]

∅:D[69.223] → [52.1335:1346]

∅:D[70.246] → [52.1335:1346]

∅:D[56.794] → [52.1335:1346]

∅:D[67.1224] → [52.1335:1346]

∅:D[59.3232] → [52.1335:1346]

∅:D[54.18933] → [52.1335:1346]

∅:D[34.37185] → [52.1335:1346]

∅:D[31.127950] → [52.1335:1346]

B:BD[52.1335] → [52.1335:1346]

∅:D[70.304] → [71.1521:1552]

∅:D[56.901] → [71.1521:1552]

∅:D[67.1350] → [71.1521:1552]

∅:D[59.3333] → [71.1521:1552]

∅:D[34.37285] → [71.1521:1552]

∅:D[31.128064] → [71.1521:1552]

B:BD[54.19025] → [71.1521:1552]

∅:D[70.346] → [72.8431:8472]

∅:D[56.992] → [72.8431:8472]

∅:D[67.1460] → [72.8431:8472]

∅:D[59.3418] → [72.8431:8472]

∅:D[34.37369] → [72.8431:8472]

∅:D[31.128162] → [72.8431:8472]

B:BD[68.122] → [72.8431:8472]

B:BD[72.8472] → [56.993:1081]

∅:D[56.1081] → [68.254:303]

∅:D[31.128258] → [68.254:303]

B:BD[68.254] → [68.254:303]

∅:D[66.1244] → [68.347:373]

B:BD[68.347] → [68.347:373]

∅:D[73.157] → [68.373:404]

B:BD[68.373] → [68.373:404]

∅:D[74.85] → [68.488:503]

∅:D[75.603] → [68.488:503]

∅:D[56.1115] → [68.488:503]

∅:D[31.128299] → [68.488:503]

B:BD[68.488] → [68.488:503]

∅:D[74.155] → [68.582:596]

B:BD[68.582] → [68.582:596]

∅:D[74.263] → [68.703:715]

∅:D[56.1204] → [68.703:715]

∅:D[72.8555] → [68.703:715]

∅:D[31.128395] → [68.703:715]

B:BD[68.703] → [68.703:715]

B:BD[68.596] → [56.1116:1204]

B:BD[68.503] → [74.86:155]

B:BD[68.404] → [56.1082:1115]

B:BD[68.373] → [73.94:157]

B:BD[68.303] → [66.1193:1244]

B:BD[71.1552] → [76.15:37]

B:BD[76.37] → [70.305:346]

∅:D[68.715] → [52.1459:1483]

∅:D[71.1674] → [52.1459:1483]

∅:D[54.19025] → [52.1459:1483]

B:BD[52.1459] → [52.1459:1483]

∅:D[77.12048] → [52.1521:1525]

∅:D[54.27620] → [52.1521:1525]

B:BD[52.1521] → [52.1521:1525]

∅:D[56.1266] → [78.10:15]

∅:D[67.1528] → [78.10:15]

∅:D[13.2357] → [78.10:15]

∅:D[59.3474] → [78.10:15]

∅:D[34.37424] → [78.10:15]

∅:D[31.128464] → [78.10:15]

B:BD[54.19072] → [78.10:15]

∅:D[65.257] → [78.69:187]

∅:D[79.293] → [78.69:187]

∅:D[67.1617] → [78.69:187]

B:BD[78.69] → [78.69:187]

∅:D[65.333] → [78.328:509]

∅:D[67.1787] → [78.328:509]

B:BD[78.328] → [78.328:509]

∅:D[65.395] → [80.1653:1746]

∅:D[67.1943] → [80.1653:1746]

B:BD[78.636] → [80.1653:1746]

∅:D[80.1746] → [78.674:800]

B:BD[78.674] → [78.674:800]

∅:D[65.469] → [78.939:1048]

∅:D[67.2111] → [78.939:1048]

B:BD[78.939] → [78.939:1048]

∅:D[65.539] → [78.1183:1220]

∅:D[67.2275] → [78.1183:1220]

B:BD[78.1183] → [78.1183:1220]

∅:D[76.56] → [78.1220:1268]

∅:D[71.1693] → [78.1220:1268]

B:BD[78.1220] → [78.1220:1268]

∅:D[65.637] → [78.1391:1473]

∅:D[67.2420] → [78.1391:1473]

B:BD[78.1391] → [78.1391:1473]

∅:D[65.781] → [78.1642:1680]

∅:D[67.2611] → [78.1642:1680]

B:BD[78.1642] → [78.1642:1680]

B:BD[78.1680] → [80.1747:1761]

∅:D[80.1761] → [78.1680:1738]

B:BD[78.1680] → [78.1680:1738]

∅:D[19.148] → [78.1793:1825]

∅:D[65.1047] → [78.1793:1825]

∅:D[67.2701] → [78.1793:1825]

B:BD[78.1793] → [78.1793:1825]

∅:D[81.142] → [78.1909:1944]

∅:D[67.2763] → [78.1909:1944]

B:BD[78.1909] → [78.1909:1944]

∅:D[82.104] → [78.2082:2164]

∅:D[64.217] → [78.2082:2164]

∅:D[83.1730] → [78.2082:2164]

B:BD[78.2082] → [78.2082:2164]

B:BD[78.2164] → [63.76:116]

∅:D[65.1099] → [78.2287:2327]

∅:D[67.2915] → [78.2287:2327]

B:BD[78.2287] → [78.2287:2327]

∅:D[82.199] → [78.2465:2547]

∅:D[64.318] → [78.2465:2547]

∅:D[83.1817] → [78.2465:2547]

B:BD[78.2465] → [78.2465:2547]

∅:D[63.157] → [78.2547:2597]

B:BD[78.2547] → [78.2547:2597]

∅:D[65.1163] → [78.2724:2733]

∅:D[67.3071] → [78.2724:2733]

B:BD[78.2724] → [78.2724:2733]

∅:D[65.1222] → [78.2860:3081]

∅:D[67.3227] → [78.2860:3081]

B:BD[78.2860] → [78.2860:3081]

∅:D[65.1296] → [78.3220:3256]

∅:D[67.3395] → [78.3220:3256]

B:BD[78.3220] → [78.3220:3256]

∅:D[65.1352] → [80.1853:1893]

∅:D[83.1926] → [80.1853:1893]

∅:D[67.3518] → [80.1853:1893]

B:BD[78.3372] → [80.1853:1893]

∅:D[83.1976] → [80.1950:2035]

B:BD[80.1950] → [80.1950:2035]

∅:D[65.1412] → [80.2127:2201]

∅:D[67.3625] → [80.2127:2201]

B:BD[80.2127] → [80.2127:2201]

∅:D[64.399] → [80.2267:2380]

B:BD[80.2267] → [80.2267:2380]

∅:D[65.1705] → [80.2936:2973]

∅:D[67.4294] → [80.2936:2973]

B:BD[80.2936] → [80.2936:2973]

∅:D[83.2026] → [80.3030:3115]

B:BD[80.3030] → [80.3030:3115]

∅:D[65.1765] → [80.3207:3281]

∅:D[67.4401] → [80.3207:3281]

B:BD[80.3207] → [80.3207:3281]

∅:D[64.480] → [80.3347:3457]

B:BD[80.3347] → [80.3347:3457]

∅:D[65.2058] → [78.3372:3457]

∅:D[80.4013] → [78.3372:3457]

∅:D[67.5070] → [78.3372:3457]

B:BD[78.3372] → [78.3372:3457]

∅:D[82.294] → [78.3555:3637]

∅:D[64.581] → [78.3555:3637]

∅:D[83.2113] → [78.3555:3637]

B:BD[78.3555] → [78.3555:3637]

∅:D[83.2201] → [78.3810:3892]

B:BD[78.3810] → [78.3810:3892]

∅:D[82.389] → [78.3990:4158]

∅:D[64.682] → [78.3990:4158]

∅:D[83.2288] → [78.3990:4158]

B:BD[78.3990] → [78.3990:4158]

∅:D[65.2150] → [67.5256:5379]

B:BD[67.5256] → [67.5256:5379]

∅:D[67.5379] → [84.99:134]

B:BD[78.4352] → [84.99:134]

B:BD[84.134] → [71.1694:1787]

∅:D[71.1787] → [84.134:192]

B:BD[84.134] → [84.134:192]

∅:D[84.192] → [80.4014:4061]

B:BD[78.4352] → [80.4014:4061]

∅:D[80.4061] → [78.4352:4358]

B:BD[78.4352] → [78.4352:4358]

∅:D[78.4358] → [85.641:646]

B:BD[54.19072] → [85.641:646]

∅:D[13.2501] → [67.5435:5462]

B:BD[86.2271] → [67.5435:5462]

B:BD[67.5462] → [13.2502:2623]

∅:D[57.716] → [85.795:800]

∅:D[28.1725] → [85.795:800]

∅:D[58.2043] → [85.795:800]

∅:D[13.2623] → [85.795:800]

∅:D[60.4578] → [85.795:800]

∅:D[67.5567] → [85.795:800]

∅:D[61.7072] → [85.795:800]

∅:D[34.37549] → [85.795:800]

∅:D[31.128620] → [85.795:800]

B:BD[85.795] → [85.795:800]

∅:D[87.26] → [80.4186:4193]

∅:D[84.281] → [80.4186:4193]

B:BD[85.1671] → [80.4186:4193]

∅:D[88.1301] → [80.4225:4243]

∅:D[31.129908] → [80.4225:4243]

B:BD[80.4225] → [80.4225:4243]

∅:D[80.4243] → [85.1671:1677]

B:BD[85.1671] → [85.1671:1677]

∅:D[89.134] → [90.49:54]

B:BD[85.1703] → [90.49:54]

B:BD[90.54] → [91.32:118]

∅:D[92.179] → [91.218:254]

∅:D[89.225] → [91.218:254]

∅:D[13.2924] → [91.218:254]

∅:D[31.130025] → [91.218:254]

B:BD[91.218] → [91.218:254]

∅:D[93.65] → [94.1585:1613]

∅:D[95.189] → [94.1585:1613]

∅:D[13.2988] → [94.1585:1613]

B:BD[83.2333] → [94.1585:1613]

B:BD[94.1613] → [13.2989:3074]

∅:D[93.139] → [91.384:433]

∅:D[13.3074] → [91.384:433]

∅:D[67.6027] → [91.384:433]

B:BD[91.384] → [91.384:433]

∅:D[96.155] → [91.565:614]

∅:D[95.249] → [91.565:614]

∅:D[92.319] → [91.565:614]

∅:D[64.1464] → [91.565:614]

∅:D[83.2488] → [91.565:614]

∅:D[59.4062] → [91.565:614]

∅:D[34.38138] → [91.565:614]

∅:D[31.130172] → [91.565:614]

B:BD[91.565] → [91.565:614]

∅:D[93.248] → [91.684:772]

∅:D[92.405] → [91.684:772]

∅:D[64.1569] → [91.684:772]

∅:D[59.4142] → [91.684:772]

∅:D[34.38217] → [91.684:772]

∅:D[31.130265] → [91.684:772]

B:BD[91.684] → [91.684:772]

B:BD[91.772] → [50.1255:1334]

∅:D[50.1334] → [91.772:790]

B:BD[91.772] → [91.772:790]

∅:D[97.204] → [91.949:1033]

∅:D[93.429] → [91.949:1033]

∅:D[92.541] → [91.949:1033]

∅:D[64.1672] → [91.949:1033]

∅:D[13.3161] → [91.949:1033]

∅:D[59.4220] → [91.949:1033]

∅:D[34.38294] → [91.949:1033]

∅:D[31.130415] → [91.949:1033]

B:BD[91.949] → [91.949:1033]

B:BD[91.1033] → [50.1335:1412]

∅:D[50.1412] → [91.1033:1041]

B:BD[91.1033] → [91.1033:1041]

B:BD[91.1041] → [80.4244:4251]

B:BD[80.4251] → [84.282:300]

∅:D[84.300] → [91.1041:1052]

∅:D[80.4301] → [91.1041:1052]

B:BD[91.1041] → [91.1041:1052]

B:BD[91.1052] → [50.1413:1875]

∅:D[98.396] → [41.2049:2057]

∅:D[31.130738] → [41.2049:2057]

B:BD[41.2049] → [41.2049:2057]

B:BD[41.2057] → [98.397:487]

B:BD[98.487] → [13.3162:3237]

∅:D[99.123] → [90.338:399]

∅:D[51.1216] → [90.338:399]

B:BD[90.338] → [90.338:399]

∅:D[99.518] → [90.847:859]

B:BD[90.847] → [90.847:859]

∅:D[99.765] → [90.1135:1191]

B:BD[90.1135] → [90.1135:1191]

∅:D[100.171] → [90.1307:1322]

∅:D[101.540] → [90.1307:1322]

∅:D[99.870] → [90.1307:1322]

∅:D[67.6297] → [90.1307:1322]

B:BD[90.1307] → [90.1307:1322]

∅:D[100.252] → [90.1438:1452]

∅:D[101.629] → [90.1438:1452]

∅:D[99.975] → [90.1438:1452]

∅:D[67.6399] → [90.1438:1452]

B:BD[90.1438] → [90.1438:1452]

∅:D[99.1178] → [90.1684:1696]

B:BD[90.1684] → [90.1684:1696]

∅:D[99.1519] → [90.2042:2054]

B:BD[90.2042] → [90.2042:2054]

∅:D[99.1951] → [80.4894:5015]

B:BD[80.4894] → [80.4894:5015]

∅:D[99.2220] → [80.5319:5400]

B:BD[80.5319] → [80.5319:5400]

∅:D[99.2649] → [80.5882:6000]

B:BD[80.5882] → [80.5882:6000]

∅:D[99.2918] → [80.6304:6330]

B:BD[80.6304] → [80.6304:6330]

B:BD[80.6330] → [99.2919:2970]

∅:D[98.1105] → [99.3040:3172]

∅:D[64.2306] → [99.3040:3172]

∅:D[13.4044] → [99.3040:3172]

∅:D[59.4796] → [99.3040:3172]

∅:D[34.38863] → [99.3040:3172]

∅:D[31.131510] → [99.3040:3172]

B:BD[99.3040] → [99.3040:3172]

∅:D[17.95] → [99.3243:3299]

B:BD[99.3243] → [99.3243:3299]

B:BD[99.3172] → [17.17:95]

B:BD[99.2970] → [13.3932:4044]

∅:D[101.1186] → [99.2860:2918]

∅:D[67.7138] → [99.2860:2918]

B:BD[99.2860] → [99.2860:2918]

B:BD[80.6000] → [67.6886:7138]

B:BD[80.5400] → [99.2221:2366]

∅:D[98.1019] → [99.2438:2649]

∅:D[64.2201] → [99.2438:2649]

∅:D[13.3931] → [99.2438:2649]

∅:D[59.4716] → [99.2438:2649]

∅:D[34.38784] → [99.2438:2649]

∅:D[31.131417] → [99.2438:2649]

B:BD[99.2438] → [99.2438:2649]

B:BD[99.2366] → [13.3817:3931]

∅:D[101.959] → [99.2162:2220]

∅:D[67.6885] → [99.2162:2220]

B:BD[99.2162] → [99.2162:2220]

B:BD[80.5015] → [67.6633:6885]

∅:D[99.3299] → [90.2548:2560]

B:BD[90.2548] → [90.2548:2560]

∅:D[99.3718] → [90.3032:3044]

B:BD[90.3032] → [90.3032:3044]

B:BD[87.101] → [99.3769:3818]

∅:D[99.3818] → [87.102:121]

B:BD[102.155] → [87.102:121]

∅:D[87.121] → [80.6331:6342]

∅:D[102.202] → [80.6331:6342]

B:BD[90.3044] → [80.6331:6342]

∅:D[99.3855] → [80.6384:6406]

B:BD[80.6384] → [80.6384:6406]

B:BD[80.6342] → [99.3819:3855]

∅:D[80.6406] → [90.3044:3054]

B:BD[90.3044] → [90.3044:3054]

∅:D[89.380] → [90.3113:3127]

∅:D[98.1279] → [90.3113:3127]

∅:D[31.131705] → [90.3113:3127]

B:BD[90.3113] → [90.3113:3127]

∅:D[103.207] → [54.19072:19077]

∅:D[85.1703] → [54.19072:19077]

∅:D[90.3159] → [54.19072:19077]

∅:D[104.8359] → [54.19072:19077]

B:BD[54.19072] → [54.19072:19077]

∅:D[105.111] → [94.1614:1665]

∅:D[53.930] → [94.1614:1665]

B:BD[77.5258] → [94.1614:1665]

B:BD[94.1665] → [105.112:156]

∅:D[105.156] → [106.15:64]

∅:D[31.131757] → [106.15:64]

B:BD[77.5858] → [106.15:64]

∅:D[107.137] → [106.146:193]

B:BD[106.146] → [106.146:193]

∅:D[101.1317] → [106.315:724]

∅:D[67.7282] → [106.315:724]

B:BD[106.315] → [106.315:724]

∅:D[105.238] → [106.758:807]

∅:D[31.131853] → [106.758:807]

B:BD[106.758] → [106.758:807]

∅:D[107.197] → [106.900:947]

B:BD[106.900] → [106.900:947]

∅:D[101.1448] → [106.1069:1550]

∅:D[67.7426] → [106.1069:1550]

B:BD[106.1069] → [106.1069:1550]

∅:D[105.330] → [94.1666:1721]

∅:D[106.1589] → [94.1666:1721]

∅:D[31.131959] → [94.1666:1721]

B:BD[77.5858] → [94.1666:1721]

∅:D[105.374] → [94.1722:1771]

∅:D[31.132010] → [94.1722:1771]

B:BD[77.5955] → [94.1722:1771]

∅:D[108.64] → [77.6092:6139]

∅:D[107.251] → [77.6092:6139]

B:BD[77.6092] → [77.6092:6139]

∅:D[101.1587] → [77.6269:6467]

∅:D[67.7578] → [77.6269:6467]

B:BD[77.6269] → [77.6269:6467]

∅:D[109.103] → [110.98:131]

B:BD[110.98] → [110.98:131]

∅:D[110.131] → [77.6467:6652]

B:BD[77.6467] → [77.6467:6652]

∅:D[101.1999] → [36.9887:9984]

∅:D[67.8042] → [36.9887:9984]

B:BD[77.6946] → [36.9887:9984]

∅:D[36.9984] → [77.6946:6992]

B:BD[77.6946] → [77.6946:6992]

∅:D[108.260] → [77.7225:7258]

∅:D[107.521] → [77.7225:7258]

∅:D[13.4616] → [77.7225:7258]

B:BD[77.7225] → [77.7225:7258]

∅:D[105.1283] → [77.7414:7472]

∅:D[64.2786] → [77.7414:7472]

∅:D[13.4749] → [77.7414:7472]

∅:D[34.39239] → [77.7414:7472]

∅:D[31.133010] → [77.7414:7472]

B:BD[77.7414] → [77.7414:7472]

∅:D[18.89] → [77.7537:7608]

B:BD[77.7537] → [77.7537:7608]

∅:D[108.309] → [77.7744:7791]

∅:D[107.575] → [77.7744:7791]

B:BD[77.7744] → [77.7744:7791]

∅:D[101.2134] → [77.7917:8053]

∅:D[67.8190] → [77.7917:8053]

B:BD[77.7917] → [77.7917:8053]

∅:D[111.506] → [77.8103:8206]

B:BD[77.8103] → [77.8103:8206]

∅:D[112.86] → [77.10152:10172]

∅:D[108.417] → [77.10152:10172]

∅:D[107.651] → [77.10152:10172]

∅:D[50.1946] → [77.10152:10172]

∅:D[13.4836] → [77.10152:10172]

B:BD[77.10152] → [77.10152:10172]

∅:D[89.419] → [77.10357:10365]

∅:D[105.1680] → [77.10357:10365]

∅:D[31.133463] → [77.10357:10365]

B:BD[77.10357] → [77.10357:10365]

B:BD[71.1826] → [94.2716:2771]

B:BD[94.2771] → [13.4837:4933]

∅:D[112.340] → [71.1952:1972]

∅:D[108.545] → [71.1952:1972]

∅:D[107.737] → [71.1952:1972]

∅:D[13.4933] → [71.1952:1972]

B:BD[71.1952] → [71.1952:1972]

∅:D[105.1839] → [71.2059:2077]

∅:D[31.133650] → [71.2059:2077]

B:BD[71.2059] → [71.2059:2077]

∅:D[89.497] → [77.10680:10688]

∅:D[105.2024] → [77.10680:10688]

∅:D[31.133856] → [77.10680:10688]

B:BD[77.10680] → [77.10680:10688]

∅:D[108.604] → [77.10804:11312]

∅:D[107.801] → [77.10804:11312]

∅:D[13.4999] → [77.10804:11312]

B:BD[77.10804] → [77.10804:11312]

∅:D[107.867] → [77.11372:11429]

∅:D[13.5067] → [77.11372:11429]

B:BD[77.11372] → [77.11372:11429]

∅:D[107.927] → [77.11543:11594]

B:BD[77.11543] → [77.11543:11594]

B:BD[77.11778] → [77.11778:11786]

∅:D[80.10586] → [77.11786:11792]

B:BD[77.11786] → [77.11786:11792]

∅:D[80.10691] → [77.11792:11797]

B:BD[77.11792] → [77.11792:11797]

∅:D[108.653] → [54.19200:19238]

∅:D[107.1077] → [54.19200:19238]

∅:D[31.133918] → [54.19200:19238]

B:BD[54.19200] → [54.19200:19238]

∅:D[108.691] → [54.19373:19415]

∅:D[13.5256] → [54.19373:19415]

B:BD[54.19373] → [54.19373:19415]

∅:D[107.1166] → [54.19492:19530]

∅:D[13.5311] → [54.19492:19530]

∅:D[31.133968] → [54.19492:19530]

B:BD[54.19492] → [54.19492:19530]

∅:D[113.819] → [54.19800:19928]

∅:D[107.1252] → [54.19800:19928]

∅:D[64.2891] → [54.19800:19928]

∅:D[59.5156] → [54.19800:19928]

∅:D[13.5564] → [54.19800:19928]

∅:D[34.39318] → [54.19800:19928]

∅:D[31.134061] → [54.19800:19928]

B:BD[54.19800] → [54.19800:19928]

∅:D[13.5611] → [54.19963:20018]

B:BD[54.19963] → [54.19963:20018]

∅:D[108.740] → [54.20095:20133]

∅:D[107.1353] → [54.20095:20133]

∅:D[31.134123] → [54.20095:20133]

B:BD[54.20095] → [54.20095:20133]

∅:D[113.937] → [54.20403:20476]

∅:D[107.1439] → [54.20403:20476]

∅:D[64.2996] → [54.20403:20476]

∅:D[59.5236] → [54.20403:20476]

∅:D[13.5864] → [54.20403:20476]

∅:D[34.39397] → [54.20403:20476]

∅:D[31.134216] → [54.20403:20476]

B:BD[54.20403] → [54.20403:20476]

∅:D[108.790] → [54.20556:20611]

∅:D[13.5925] → [54.20556:20611]

B:BD[54.20556] → [54.20556:20611]

∅:D[107.1530] → [54.20690:20728]

∅:D[13.5980] → [54.20690:20728]

∅:D[31.134266] → [54.20690:20728]

B:BD[54.20690] → [54.20690:20728]

∅:D[113.985] → [54.20896:21152]

∅:D[13.6121] → [54.20896:21152]

∅:D[67.8537] → [54.20896:21152]

B:BD[54.20896] → [54.20896:21152]

∅:D[3.104] → [54.21190:21499]

B:BD[54.21190] → [54.21190:21499]

∅:D[81.483] → [54.21499:21510]

B:BD[54.21499] → [54.21499:21510]

∅:D[17.466] → [54.22708:22751]

B:BD[54.22708] → [54.22708:22751]

∅:D[101.2295] → [54.22751:22786]

B:BD[54.22751] → [54.22751:22786]

∅:D[67.8641] → [54.22823:22909]

B:BD[54.22823] → [54.22823:22909]

∅:D[69.309] → [54.23108:23113]

∅:D[59.5294] → [54.23108:23113]

∅:D[34.39461] → [54.23108:23113]

∅:D[31.134337] → [54.23108:23113]

B:BD[54.23108] → [54.23108:23113]

∅:D[114.51] → [54.27529:27533]

∅:D[57.959] → [54.27529:27533]

∅:D[58.2096] → [54.27529:27533]

∅:D[60.4637] → [54.27529:27533]

∅:D[61.7132] → [54.27529:27533]

∅:D[67.8916] → [54.27529:27533]

∅:D[34.39508] → [54.27529:27533]

∅:D[31.134410] → [54.27529:27533]

B:BD[54.27529] → [54.27529:27533]

∅:D[57.998] → [77.11944:12048]

∅:D[58.2149] → [77.11944:12048]

∅:D[64.3083] → [77.11944:12048]

∅:D[60.4696] → [77.11944:12048]

∅:D[61.7192] → [77.11944:12048]

∅:D[34.39555] → [77.11944:12048]

∅:D[31.134483] → [77.11944:12048]

B:BD[54.27620] → [77.11944:12048]

B:BD[54.27533] → [64.2997:3083]

B:BD[54.23113] → [67.8829:8916]

∅:D[67.8828] → [69.224:309]

B:BD[54.23060] → [69.224:309]

B:BD[54.22909] → [67.8642:8828]

B:BD[54.22786] → [67.8597:8641]

B:BD[54.22751] → [101.2135:2192]

∅:D[67.8596] → [101.2243:2295]

B:BD[101.2243] → [101.2243:2295]

B:BD[101.2192] → [67.8538:8596]

B:BD[54.21510] → [17.413:466]

B:BD[54.21499] → [81.186:411]

∅:D[17.412] → [81.475:483]

B:BD[81.475] → [81.475:483]

B:BD[81.411] → [17.334:412]

B:BD[54.21152] → [3.11:104]

B:BD[54.20728] → [83.4209:4257]

B:BD[83.4257] → [13.5981:6121]

B:BD[54.20611] → [107.1440:1488]

B:BD[107.1488] → [13.5926:5980]

B:BD[54.20476] → [67.8407:8465]

B:BD[67.8465] → [13.5865:5925]

B:BD[54.20133] → [83.4160:4208]

B:BD[83.4208] → [13.5612:5864]

B:BD[54.20018] → [107.1253:1353]

B:BD[54.19928] → [13.5565:5611]

B:BD[54.19530] → [83.4111:4159]

B:BD[83.4159] → [13.5312:5564]

B:BD[54.19415] → [107.1078:1124]

B:BD[107.1124] → [13.5257:5311]

B:BD[54.19238] → [13.5068:5256]

∅:D[107.1022] → [83.4066:4110]

B:BD[54.19112] → [83.4066:4110]

B:BD[83.4110] → [107.1023:1077]

B:BD[77.11797] → [107.982:1022]

B:BD[77.11792] → [80.10587:10691]

∅:D[51.1344] → [80.8168:8280]

B:BD[77.11786] → [80.8168:8280]

∅:D[2.41] → [80.8640:8674]

B:BD[80.8640] → [80.8640:8674]

∅:D[2.73] → [80.9005:9531]

B:BD[80.9005] → [80.9005:9531]

∅:D[17.203] → [80.9624:9966]

B:BD[80.9624] → [80.9624:9966]

∅:D[17.333] → [80.10081:10586]

B:BD[80.10081] → [80.10081:10586]

B:BD[80.9966] → [17.204:333]

B:BD[80.9531] → [17.96:203]

B:BD[80.8674] → [2.42:73]

B:BD[80.8280] → [2.10:41]

B:BD[77.11786] → [51.1217:1271]

∅:D[107.981] → [51.1319:1344]

B:BD[51.1319] → [51.1319:1344]

B:BD[51.1271] → [107.928:981]

B:BD[77.11429] → [94.2828:2883]

B:BD[94.2883] → [107.868:927]

B:BD[77.11312] → [13.5000:5067]

B:BD[77.10688] → [94.2772:2827]

B:BD[94.2827] → [13.4934:4999]

B:BD[71.2077] → [105.1840:2024]

∅:D[105.1730] → [115.268:293]

∅:D[31.133520] → [115.268:293]

B:BD[115.268] → [115.268:293]

∅:D[105.1796] → [115.346:356]

∅:D[31.133600] → [115.346:356]

B:BD[115.346] → [115.346:356]

B:BD[115.356] → [105.1797:1839]

B:BD[115.293] → [105.1731:1796]

B:BD[71.1972] → [105.1681:1730]

∅:D[105.1441] → [115.107:117]

∅:D[31.133196] → [115.107:117]

B:BD[115.107] → [115.107:117]

B:BD[115.117] → [105.1442:1680]

B:BD[77.10172] → [105.1327:1441]

B:BD[77.10036] → [94.2610:2665]

B:BD[94.2665] → [13.4750:4836]

B:BD[77.8053] → [111.381:506]

B:BD[77.7791] → [67.8043:8190]

B:BD[77.7608] → [94.2292:2341]

B:BD[94.2341] → [105.1284:1326]

B:BD[105.1326] → [107.522:575]

B:BD[77.7472] → [18.17:89]

B:BD[77.7258] → [13.4617:4749]

B:BD[77.6992] → [94.2149:2204]

B:BD[94.2204] → [105.1043:1177]

B:BD[105.1177] → [13.4552:4616]

∅:D[105.464] → [94.1828:1877]

∅:D[31.132114] → [94.1828:1877]

B:BD[80.6506] → [94.1828:1877]

∅:D[108.113] → [80.6645:6692]

∅:D[107.305] → [80.6645:6692]

B:BD[80.6645] → [80.6645:6692]

∅:D[101.1726] → [80.6822:7020]

∅:D[67.7730] → [80.6822:7020]

B:BD[80.6822] → [80.6822:7020]

∅:D[109.229] → [80.7020:7160]

B:BD[80.7020] → [80.7020:7160]

∅:D[111.136] → [80.7160:7207]

B:BD[80.7160] → [80.7160:7207]

∅:D[105.553] → [94.1934:1983]

∅:D[31.132217] → [94.1934:1983]

B:BD[80.7303] → [94.1934:1983]

∅:D[108.162] → [80.7439:7486]

∅:D[107.359] → [80.7439:7486]

B:BD[80.7439] → [80.7439:7486]

∅:D[101.1865] → [80.7616:7814]

∅:D[67.7882] → [80.7616:7814]

B:BD[80.7616] → [80.7616:7814]

B:BD[111.228] → [111.228:380]

B:BD[111.380] → [109.230:461]

∅:D[111.380] → [80.7954:7998]

∅:D[109.461] → [80.7954:7998]

B:BD[80.7954] → [80.7954:7998]

∅:D[101.1932] → [36.9713:9759]

∅:D[67.7962] → [36.9713:9759]

B:BD[36.9713] → [36.9713:9759]

B:BD[36.9759] → [105.797:936]

∅:D[64.2661] → [67.7963:8042]

∅:D[13.4551] → [67.7963:8042]

B:BD[34.39140] → [67.7963:8042]

B:BD[105.936] → [13.4355:4551]

B:BD[80.7998] → [105.597:690]

∅:D[64.2536] → [67.7883:7962]

∅:D[13.4354] → [67.7883:7962]

B:BD[34.39041] → [67.7883:7962]

B:BD[105.690] → [13.4158:4354]

B:BD[80.7486] → [67.7731:7882]

B:BD[94.1983] → [105.554:596]

B:BD[105.596] → [107.306:359]

B:BD[80.7207] → [94.1878:1933]

B:BD[94.1933] → [105.511:553]

B:BD[80.7020] → [109.104:229]

B:BD[80.6692] → [67.7579:7730]

B:BD[94.1877] → [105.465:510]

B:BD[105.510] → [107.252:305]

B:BD[77.6652] → [94.1772:1827]

B:BD[94.1827] → [105.419:464]

B:BD[77.6467] → [109.15:103]

B:BD[77.6139] → [67.7427:7578]

B:BD[94.1771] → [105.375:418]

B:BD[105.418] → [107.198:251]

B:BD[94.1721] → [105.331:374]

B:BD[106.1550] → [105.285:330]

B:BD[106.947] → [67.7283:7426]

B:BD[106.807] → [105.239:284]

B:BD[105.284] → [107.138:197]

B:BD[106.724] → [105.198:238]

B:BD[106.193] → [67.7139:7282]

B:BD[106.64] → [105.157:197]

B:BD[105.197] → [107.84:137]

B:BD[54.19077] → [105.63:111]

B:BD[90.3054] → [98.1192:1279]

B:BD[90.2560] → [99.3300:3348]

∅:D[98.1191] → [99.3418:3718]

∅:D[64.2411] → [99.3418:3718]

∅:D[13.4157] → [99.3418:3718]

∅:D[59.4876] → [99.3418:3718]

∅:D[34.38942] → [99.3418:3718]

∅:D[31.131603] → [99.3418:3718]

B:BD[99.3418] → [99.3418:3718]

B:BD[99.3348] → [13.4045:4157]

B:BD[90.2054] → [99.1520:1668]

∅:D[98.931] → [99.1740:1951]

∅:D[64.2094] → [99.1740:1951]

∅:D[13.3816] → [99.1740:1951]

∅:D[59.4634] → [99.1740:1951]

∅:D[34.38703] → [99.1740:1951]

∅:D[31.131322] → [99.1740:1951]

B:BD[99.1740] → [99.1740:1951]

B:BD[99.1668] → [13.3702:3816]

B:BD[90.1696] → [99.1179:1231]

∅:D[98.843] → [99.1301:1369]

∅:D[64.1987] → [99.1301:1369]

∅:D[13.3701] → [99.1301:1369]

∅:D[59.4552] → [99.1301:1369]

∅:D[34.38622] → [99.1301:1369]

∅:D[31.131227] → [99.1301:1369]

B:BD[99.1301] → [99.1301:1369]

∅:D[101.732] → [99.1463:1519]

∅:D[67.6632] → [99.1463:1519]

B:BD[99.1463] → [99.1463:1519]

B:BD[99.1369] → [67.6517:6632]

B:BD[99.1231] → [13.3589:3701]

B:BD[90.1452] → [99.976:1032]

∅:D[98.757] → [99.1122:1178]

∅:D[83.2571] → [99.1122:1178]

∅:D[13.3588] → [99.1122:1178]

∅:D[59.4472] → [99.1122:1178]

∅:D[67.6516] → [99.1122:1178]

∅:D[34.38543] → [99.1122:1178]

∅:D[31.131134] → [99.1122:1178]

B:BD[99.1122] → [99.1122:1178]

B:BD[99.1032] → [13.3464:3588]

B:BD[90.1322] → [67.6298:6399]

B:BD[90.1191] → [67.6196:6297]

B:BD[90.859] → [99.519:627]

∅:D[98.659] → [99.697:765]

∅:D[64.1882] → [99.697:765]

∅:D[13.3463] → [99.697:765]

∅:D[59.4380] → [99.697:765]

∅:D[34.38452] → [99.697:765]

∅:D[31.131029] → [99.697:765]

B:BD[99.697] → [99.697:765]

B:BD[99.627] → [13.3351:3463]

B:BD[90.399] → [81.143:185]

∅:D[81.185] → [99.124:227]

B:BD[90.399] → [99.124:227]

∅:D[98.573] → [99.297:365]

∅:D[64.1777] → [99.297:365]

∅:D[13.3350] → [99.297:365]

∅:D[59.4300] → [99.297:365]

∅:D[34.38373] → [99.297:365]

∅:D[31.130936] → [99.297:365]

B:BD[99.297] → [99.297:365]

∅:D[100.90] → [99.462:518]

∅:D[101.451] → [99.462:518]

∅:D[67.6195] → [99.462:518]

B:BD[99.462] → [99.462:518]

B:BD[99.365] → [67.6099:6195]

B:BD[99.227] → [13.3238:3350]

∅:D[89.304] → [99.46:74]

∅:D[98.487] → [99.46:74]

∅:D[13.3237] → [99.46:74]

∅:D[31.130843] → [99.46:74]

B:BD[99.46] → [99.46:74]

B:BD[99.74] → [51.1094:1216]

B:BD[50.1875] → [98.71:396]

B:BD[91.790] → [92.406:457]

B:BD[92.457] → [13.3075:3161]

B:BD[91.433] → [95.190:249]

∅:D[95.77] → [93.17:65]

∅:D[11.124] → [93.17:65]

B:BD[91.254] → [93.17:65]

B:BD[93.65] → [95.78:134]

B:BD[95.134] → [13.2925:2988]

B:BD[91.118] → [92.46:179]

B:BD[92.179] → [13.2851:2924]

B:BD[80.4193] → [88.1263:1301]

∅:D[13.2788] → [116.17:71]

B:BD[88.140] → [116.17:71]

∅:D[116.124] → [88.140:191]

∅:D[13.2850] → [88.140:191]

B:BD[88.140] → [88.140:191]

∅:D[116.204] → [88.326:422]

∅:D[64.837] → [88.326:422]

∅:D[34.37678] → [88.326:422]

B:BD[88.326] → [88.326:422]

∅:D[101.133] → [88.537:740]

∅:D[116.285] → [88.537:740]

∅:D[64.993] → [88.537:740]

∅:D[67.5697] → [88.537:740]

∅:D[34.37787] → [88.537:740]

B:BD[88.537] → [88.537:740]

∅:D[101.250] → [88.855:978]

∅:D[116.366] → [88.855:978]

∅:D[64.1149] → [88.855:978]

∅:D[67.5827] → [88.855:978]

∅:D[34.37896] → [88.855:978]

B:BD[88.855] → [88.855:978]

∅:D[101.367] → [88.1093:1210]

∅:D[116.447] → [88.1093:1210]

∅:D[64.1305] → [88.1093:1210]

∅:D[67.5957] → [88.1093:1210]

∅:D[34.38005] → [88.1093:1210]

B:BD[88.1093] → [88.1093:1210]

B:BD[88.978] → [116.367:447]

B:BD[88.740] → [116.286:366]

B:BD[88.422] → [116.205:285]

B:BD[88.191] → [116.125:204]

B:BD[116.71] → [13.2789:2850]

∅:D[88.1210] → [102.11:54]

∅:D[31.129803] → [102.11:54]

B:BD[84.238] → [102.11:54]

∅:D[88.1262] → [87.11:26]

∅:D[31.129862] → [87.11:26]

B:BD[102.99] → [87.11:26]

B:BD[102.54] → [88.1211:1262]

B:BD[85.800] → [13.2624:2788]

B:BD[85.646] → [13.2358:2501]

B:BD[78.4158] → [65.2105:2150]

∅:D[65.2104] → [83.2114:2201]

∅:D[67.5163] → [83.2114:2201]

B:BD[78.3715] → [83.2114:2201]

B:BD[78.3637] → [65.2059:2104]

B:BD[80.3457] → [65.1766:2058]

B:BD[80.3115] → [65.1706:1765]

B:BD[80.2380] → [65.1413:1705]

B:BD[80.2035] → [65.1353:1412]

B:BD[78.3256] → [65.1297:1352]

B:BD[78.3081] → [65.1223:1296]

B:BD[78.2733] → [65.1164:1222]

B:BD[78.2597] → [65.1100:1163]

B:BD[78.2547] → [63.117:157]

B:BD[63.116] → [65.1048:1099]

B:BD[78.1825] → [80.1762:1852]

B:BD[80.1852] → [81.16:88]

B:BD[81.88] → [67.2702:2763]

B:BD[78.1738] → [67.2612:2701]

B:BD[67.2701] → [65.782:829]

∅:D[79.421] → [65.960:1047]

B:BD[65.960] → [65.960:1047]

B:BD[65.1047] → [19.17:148]

B:BD[65.829] → [79.294:421]

B:BD[78.1473] → [65.638:781]

B:BD[78.1268] → [65.540:637]

B:BD[78.1220] → [76.38:56]

B:BD[78.1048] → [65.470:539]

B:BD[78.800] → [65.396:469]

B:BD[78.509] → [65.334:395]

B:BD[78.187] → [65.258:333]

B:BD[78.15] → [67.1529:1617]

B:BD[67.1617] → [79.166:293]

B:BD[52.1483] → [66.1245:1279]

B:BD[66.1279] → [13.2279:2357]

B:BD[52.1346] → [66.1160:1192]

B:BD[66.1192] → [70.247:304]

∅:D[67.1080] → [66.1121:1159]

B:BD[54.18841] → [66.1121:1159]

B:BD[66.1159] → [70.171:246]

B:BD[52.1193] → [67.1030:1080]

B:BD[52.1128] → [70.17:18]

B:BD[70.18] → [79.17:93]

B:BD[79.93] → [13.2195:2278]

∅:D[79.165] → [68.10:46]

∅:D[70.170] → [68.10:46]

∅:D[13.2278] → [68.10:46]

B:BD[52.1128] → [68.10:46]

B:BD[52.1083] → [13.2115:2194]

B:BD[52.1039] → [66.1090:1120]

B:BD[52.953] → [54.18709:18755]

B:BD[54.18755] → [66.1053:1089]

B:BD[52.817] → [65.17:73]

B:BD[65.73] → [13.2051:2114]

B:BD[52.757] → [14.757:812]

B:BD[52.598] → [94.1524:1584]

B:BD[94.1584] → [14.702:756]

B:BD[52.532] → [13.1973:2050]

B:BD[52.148] → [57.221:315]

∅:D[56.85] → [83.1533:1580]

∅:D[13.1658] → [83.1533:1580]

B:BD[117.66] → [83.1533:1580]

∅:D[56.195] → [66.1026:1052]

∅:D[67.855] → [66.1026:1052]

∅:D[13.1779] → [66.1026:1052]

∅:D[34.36730] → [66.1026:1052]

∅:D[31.127281] → [66.1026:1052]

B:BD[61.6674] → [66.1026:1052]

∅:D[67.960] → [56.318:363]

∅:D[13.1895] → [56.318:363]

∅:D[34.36822] → [56.318:363]

B:BD[56.318] → [56.318:363]

B:BD[56.363] → [13.1896:1972]

B:BD[66.1052] → [13.1780:1895]

B:BD[83.1580] → [13.1659:1779]

B:BD[57.315] → [13.1501:1658]

-- primitives for editing drawings
Drawing = {}
require 'drawing_tests'
    else
    end
      return
    end
  end
  if line.show_help then
    return
  end
  for _,shape in ipairs(line.shapes) do
    assert(shape)
    else
    end
  end
    if p.deleted == nil then
      else
      end
      if p.name then
        love.graphics.print(p.name, x,y)
        if State.current_drawing_mode == 'name' and i == line.pending.target_point then
          -- create a faint red box for the name
          local name_text
          if p.name == '' then
          else
          end
        end
          love.graphics.rectangle('fill', x,y, App.width(name_text), State.line_height)
            name_text = App.newText(love.graphics.getFont(), p.name)
            name_text = State.em
          -- TODO: avoid computing name width on every repaint
          App.color(Current_name_background_color)
        -- TODO: clip
        local x,y = px(p.x)+5, py(p.y)+5
      end
    end
  end
end
end
  if shape.mode == 'freehand' then
    local prev = nil
    for _,point in ipairs(shape.points) do
      if prev then
      end
      prev = point
    end
  elseif shape.mode == 'line' or shape.mode == 'manhattan' then
    local p1 = drawing.points[shape.p1]
    local p2 = drawing.points[shape.p2]
  elseif shape.mode == 'polygon' or shape.mode == 'rectangle' or shape.mode == 'square' then
    local prev = nil
    for _,point in ipairs(shape.vertices) do
      local curr = drawing.points[point]
      if prev then
      end
      prev = curr
    end
    -- close the loop
    local curr = drawing.points[shape.vertices[1]]
  elseif shape.mode == 'circle' then
    local center = drawing.points[shape.center]
  elseif shape.mode == 'arc' then
    local center = drawing.points[shape.center]
  elseif shape.mode == 'deleted' then
    -- ignore
  else
    print(shape.mode)
    assert(false)
  end
end
  local shape = drawing.pending
  elseif shape.mode == 'line' then
    if mx < 0 or mx >= 256 or my < 0 or my >= drawing.h then
      return
    end
    local p1 = drawing.points[shape.p1]
  elseif shape.mode == 'manhattan' then
    if mx < 0 or mx >= 256 or my < 0 or my >= drawing.h then
      return
    end
    if math.abs(mx-p1.x) > math.abs(my-p1.y) then
    else
    end
  elseif shape.mode == 'polygon' then
    -- don't close the loop on a pending polygon
    local prev = nil
    for _,point in ipairs(shape.vertices) do
      local curr = drawing.points[point]
      if prev then
      end
      prev = curr
    end
  elseif shape.mode == 'rectangle' then
    local first = drawing.points[shape.vertices[1]]
    if #shape.vertices == 1 then
      return
    end
    local second = drawing.points[shape.vertices[2]]
    local thirdx,thirdy, fourthx,fourthy = Drawing.complete_rectangle(first.x,first.y, second.x,second.y, mx,my)
  elseif shape.mode == 'square' then
    local first = drawing.points[shape.vertices[1]]
    if #shape.vertices == 1 then
      return
    end
    local second = drawing.points[shape.vertices[2]]
    local thirdx,thirdy, fourthx,fourthy = Drawing.complete_square(first.x,first.y, second.x,second.y, mx,my)
  elseif shape.mode == 'circle' then
    local center = drawing.points[shape.center]
    if mx < 0 or mx >= 256 or my < 0 or my >= drawing.h then
      return
    end
  elseif shape.mode == 'arc' then
    local center = drawing.points[shape.center]
    if mx < 0 or mx >= 256 or my < 0 or my >= drawing.h then
      return
    end
    shape.end_angle = geom.angle_with_hint(center.x,center.y, mx,my, shape.end_angle)
    love.graphics.arc('line', 'open', cx,cy, Drawing.pixels(shape.radius, width), shape.start_angle, shape.end_angle, 360)
  elseif shape.mode == 'move' then
    -- nothing pending; changes are immediately committed
  elseif shape.mode == 'name' then
    -- nothing pending; changes are immediately committed
  else
    print(shape.mode)
    assert(false)
  end
end
  local width = right-left
  return y >= line_cache.starty and y < line_cache.starty + Drawing.pixels(drawing.h, width) and x >= left and x < right
end
  else
    assert(false)
  end
end
-- a couple of operations on drawings need to constantly check the state of the mouse
  assert(drawing.mode == 'drawing')
  if App.mouse_down(1) then
    if Drawing.in_drawing(drawing, line_cache, pmx,pmy, State.left,State.right) then
      if drawing.pending.mode == 'freehand' then
      elseif drawing.pending.mode == 'move' then
        drawing.pending.target_point.x = mx
        drawing.pending.target_point.y = my
        Drawing.relax_constraints(drawing, drawing.pending.target_point_index)
      end
    end
      drawing.pending.target_point.x = mx
      drawing.pending.target_point.y = my
      Drawing.relax_constraints(drawing, drawing.pending.target_point_index)
    end
  else
    -- do nothing
  end
end
function Drawing.relax_constraints(drawing, p)
  for _,shape in ipairs(drawing.shapes) do
    if shape.mode == 'manhattan' then
      if shape.p1 == p then
        shape.mode = 'line'
      elseif shape.p2 == p then
        shape.mode = 'line'
      end
    elseif shape.mode == 'rectangle' or shape.mode == 'square' then
      for _,v in ipairs(shape.vertices) do
        if v == p then
          shape.mode = 'polygon'
        end
      end
    end
  end
end
    end
  elseif State.lines.current_drawing then
    local drawing = State.lines.current_drawing
    local line_cache = State.line_cache[State.lines.current_drawing_index]
        -- the last point added during update is good enough
        end
          if math.abs(mx-p1.x) > math.abs(my-p1.y) then
          else
          end
        end
        end
            local thirdx,thirdy, fourthx,fourthy = Drawing.complete_rectangle(first.x,first.y, second.x,second.y, mx,my)
          end
        else
          -- too few points; draw nothing
        end
            local thirdx,thirdy, fourthx,fourthy = Drawing.complete_square(first.x,first.y, second.x,second.y, mx,my)
          end
        end
      elseif drawing.pending.mode == 'circle' then
        if mx >= 0 and mx < 256 and my >= 0 and my < drawing.h then
          local center = drawing.points[drawing.pending.center]
          table.insert(drawing.shapes, drawing.pending)
          drawing.pending.radius = round(geom.dist(center.x,center.y, mx,my))
        local mx,my = Drawing.coord(x-State.left, State.width), Drawing.coord(y-line_cache.starty, State.width)
            table.insert(drawing.shapes, drawing.pending)
            table.insert(drawing.pending.vertices, Drawing.find_or_insert_point(drawing.points, thirdx,thirdy, State.width))
            table.insert(drawing.pending.vertices, Drawing.find_or_insert_point(drawing.points, fourthx,fourthy, State.width))
      elseif drawing.pending.mode == 'square' then
        assert(#drawing.pending.vertices <= 2)
        if #drawing.pending.vertices == 2 then
          if mx >= 0 and mx < 256 and my >= 0 and my < drawing.h then
            local first = drawing.points[drawing.pending.vertices[1]]
            local second = drawing.points[drawing.pending.vertices[2]]
          local mx,my = Drawing.coord(x-State.left, State.width), Drawing.coord(y-line_cache.starty, State.width)
            table.insert(drawing.shapes, drawing.pending)
            table.insert(drawing.pending.vertices, Drawing.find_or_insert_point(drawing.points, thirdx,thirdy, State.width))
            table.insert(drawing.pending.vertices, Drawing.find_or_insert_point(drawing.points, fourthx,fourthy, State.width))
        end
        end
      elseif drawing.pending.mode == 'name' then
        -- drop it
      else
        assert(false)
        print(drawing.pending.mode)
      end
    end
  end
end
  if chord == 'C-p' and not App.mouse_down(1) then
    State.current_drawing_mode = 'freehand'
  elseif App.mouse_down(1) and chord == 'l' then
    if drawing.pending.mode == 'freehand' then
    elseif drawing.pending.mode == 'polygon' or drawing.pending.mode == 'rectangle' or drawing.pending.mode == 'square' then
      drawing.pending.p1 = drawing.pending.vertices[1]
    elseif drawing.pending.mode == 'circle' or drawing.pending.mode == 'arc' then
      drawing.pending.p1 = drawing.pending.center
    end
    drawing.pending.mode = 'line'
  elseif chord == 'C-l' and not App.mouse_down(1) then
  elseif App.mouse_down(1) and chord == 'm' then
    if drawing.pending.mode == 'freehand' then
    elseif drawing.pending.mode == 'line' then
      -- do nothing
    elseif drawing.pending.mode == 'polygon' or drawing.pending.mode == 'rectangle' or drawing.pending.mode == 'square' then
      drawing.pending.p1 = drawing.pending.vertices[1]
    elseif drawing.pending.mode == 'circle' or drawing.pending.mode == 'arc' then
      drawing.pending.p1 = drawing.pending.center
    end
    drawing.pending.mode = 'manhattan'
  elseif chord == 'C-m' and not App.mouse_down(1) then
  elseif chord == 'C-g' and not App.mouse_down(1) then
  elseif App.mouse_down(1) and chord == 'g' then
    if drawing.pending.mode == 'freehand' then
    elseif drawing.pending.mode == 'line' or drawing.pending.mode == 'manhattan' then
      if drawing.pending.vertices == nil then
        drawing.pending.vertices = {drawing.pending.p1}
      end
      -- reuse existing vertices
    elseif drawing.pending.mode == 'circle' or drawing.pending.mode == 'arc' then
      drawing.pending.vertices = {drawing.pending.center}
    end
    drawing.pending.mode = 'polygon'
    while #drawing.pending.vertices >= 2 do
      table.remove(drawing.pending.vertices)
    end
    table.insert(drawing.pending.vertices, j)
    drawing.pending.mode = 'arc'
    local center = drawing.points[drawing.pending.center]
    drawing.pending.start_angle = geom.angle(center.x,center.y, mx,my)
    if drawing.pending.mode == 'freehand' then
    elseif drawing.pending.mode == 'line' or drawing.pending.mode == 'manhattan' then
      drawing.pending.center = drawing.pending.p1
      drawing.pending.center = drawing.pending.vertices[1]
    end
    drawing.pending.mode = 'circle'
    if drawing then
    end
  elseif chord == 'C-n' and not App.mouse_down(1) then
    local drawing_index,drawing,line_cache,point_index,p = Drawing.select_point_at_mouse(State)
    if drawing then
      p.name = ''
    end
    if drawing then
      for _,shape in ipairs(drawing.shapes) do
        if Drawing.contains_point(shape, i) then
          if shape.mode == 'polygon' then
            local idx = table.find(shape.vertices, i)
            assert(idx)
            table.remove(shape.vertices, idx)
            if #shape.vertices < 3 then
              shape.mode = 'deleted'
            end
          else
            shape.mode = 'deleted'
          end
        end
      end
      drawing.points[i].deleted = true
    end
    if drawing then
      shape.mode = 'deleted'
    end
    if drawing then
      drawing.show_help = true
    end
  end
end
    if drawing.mode == 'drawing' then
      end
    end
  end
  return nil
end
    if drawing.mode == 'drawing' then
        for i,shape in ipairs(drawing.shapes) do
          assert(shape)
          if geom.on_shape(mx,my, drawing, shape) then
          end
        end
      end
    end
  end
end
    if drawing.mode == 'drawing' then
        for i,point in ipairs(drawing.points) do
          assert(point)
          end
        end
      end
    end
  end
end
    if drawing.mode == 'drawing' then
        return drawing
      end
    end
  end
end
function Drawing.contains_point(shape, p)
  if shape.mode == 'freehand' then
    -- not supported
  elseif shape.mode == 'line' or shape.mode == 'manhattan' then
    return shape.p1 == p or shape.p2 == p
    return table.find(shape.vertices, p)
  elseif shape.mode == 'circle' then
    return shape.center == p
  elseif shape.mode == 'arc' then
    return shape.center == p
    -- ugh, how to support angles
  elseif shape.mode == 'deleted' then
    -- already done
  else
    print(shape.mode)
    assert(false)
  end
end
function Drawing.insert_point(points, x,y)
  for i,point in ipairs(points) do
      return i
    end
  end
  table.insert(points, {x=x, y=y})
  return #points
end
end
end
end
function table.find(h, x)
  for k,v in pairs(h) do
    if v == x then
      return k
    end
  end
function Drawing.coord(n, width)  -- pixels to parts
  return math.floor(n*256/width)
function Drawing.pixels(n, width)  -- parts to pixels
  return math.floor(n*width/256)
  return (cx-px)*(cx-px) + (cy-py)*(cy-py) < Same_point_distance*Same_point_distance
function Drawing.near(point, x,y, width)
  local px,py = Drawing.pixels(x, width),Drawing.pixels(y, width)
  local cx,cy = Drawing.pixels(point.x, width), Drawing.pixels(point.y, width)
    if Drawing.near(point, x,y, width) then
  table.insert(points, {x=x, y=y})
  return #points
end
  -- check if UI would snap the two points together
function Drawing.find_or_insert_point(points, x,y, width)
function round(num)
  return math.floor(num+.5)
end
  end
end
function Drawing.smoothen(shape)
  assert(shape.mode == 'freehand')
  for _=1,7 do
    for i=2,#shape.points-1 do
      local a = shape.points[i-1]
      local b = shape.points[i]
      local c = shape.points[i+1]
    end
      b.x = round((a.x + b.x + c.x)/3)
      b.y = round((a.y + b.y + c.y)/3)
  elseif shape.mode == 'polygon' or shape.mode == 'rectangle' or shape.mode == 'square' then
      local x, y = App.mouse_x(), App.mouse_y()
      local line_cache = State.line_cache[drawing_index]
      if Drawing.in_drawing(drawing, line_cache, x,y, State.left,State.right) then
function Drawing.select_drawing_at_mouse(State)
  for drawing_index,drawing in ipairs(State.lines) do
          if Drawing.near(point, mx,my, State.width) then
            return drawing_index,drawing,line_cache,i,point
      local x, y = App.mouse_x(), App.mouse_y()
      local line_cache = State.line_cache[drawing_index]
      if Drawing.in_drawing(drawing, line_cache, x,y, State.left,State.right) then
        local mx,my = Drawing.coord(x-State.left, State.width), Drawing.coord(y-line_cache.starty, State.width)
function Drawing.select_point_at_mouse(State)
  for drawing_index,drawing in ipairs(State.lines) do
            return drawing,line_cache,i,shape
      local x, y = App.mouse_x(), App.mouse_y()
      local line_cache = State.line_cache[drawing_index]
      if Drawing.in_drawing(drawing, line_cache, x,y, State.left,State.right) then
        local mx,my = Drawing.coord(x-State.left, State.width), Drawing.coord(y-line_cache.starty, State.width)
function Drawing.select_shape_at_mouse(State)
  for drawing_index,drawing in ipairs(State.lines) do
      local line_cache = State.line_cache[drawing_index]
      if Drawing.in_drawing(drawing, line_cache, x,y, State.left,State.right) then
        return drawing_index,drawing,line_cache
  local x, y = App.mouse_x(), App.mouse_y()
  for drawing_index,drawing in ipairs(State.lines) do
function Drawing.current_drawing(State)
  local fourthx = firstx+deltay
  local fourthy = firsty-deltax
  return thirdx,thirdy, fourthx,fourthy
  end
end
function Drawing.complete_rectangle(firstx,firsty, secondx,secondy, x,y)
  if firstx == secondx then
  end
  if firsty == secondy then
  end
  local first_slope = (secondy-firsty)/(secondx-firstx)
  -- slope of second edge:
  --    -1/first_slope
  -- equation of line containing the second edge:
  --    y-secondy = -1/first_slope*(x-secondx)
  -- => 1/first_slope*x + y + (- secondy - secondx/first_slope) = 0
  -- now we want to find the point on this line that's closest to the mouse pointer.
  -- https://en.wikipedia.org/wiki/Distance_from_a_point_to_a_line#Line_defined_by_an_equation
  local a = 1/first_slope
  local c = -secondy - secondx/first_slope
  -- slope of third edge = first_slope
  -- equation of line containing third edge:
  --     y - thirdy = first_slope*(x-thirdx)
  --  => -first_slope*x + y + (-thirdy + thirdx*first_slope) = 0
  -- now we want to find the point on this line that's closest to the first point
  local a = -first_slope
  local c = -thirdy + thirdx*first_slope
  return thirdx,thirdy, fourthx,fourthy
end
function Drawing.complete_square(firstx,firsty, secondx,secondy, x,y)
  -- use x,y only to decide which side of the first edge to complete the square on
  local deltax = secondx-firstx
  local deltay = secondy-firsty
  local thirdx = secondx+deltay
  local thirdy = secondy-deltax
  if not geom.same_side(firstx,firsty, secondx,secondy, thirdx,thirdy, x,y) then
    deltax = -deltax
    deltay = -deltay
    thirdx = secondx+deltay
    thirdy = secondy-deltax
  local fourthx = round(((firstx-a*firsty) - a*c) / (a*a + 1))
  local fourthy = round((a*(-firstx + a*firsty) - c) / (a*a + 1))
  local thirdx = round(((x-a*y) - a*c) / (a*a + 1))
  local thirdy = round((a*(-x + a*y) - c) / (a*a + 1))
    return secondx,y, firstx,y
    return x,secondy, x,firsty
  elseif chord == 'escape' and App.mouse_down(1) then
    drawing.pending = {}
    local _,drawing = Drawing.current_drawing(State)
  elseif chord == 'C-h' and not App.mouse_down(1) then
    local drawing = Drawing.select_drawing_at_mouse(State)
    local drawing,_,_,shape = Drawing.select_shape_at_mouse(State)
  elseif chord == 'C-d' and not App.mouse_down(1) then
    local _,drawing,_,i,p = Drawing.select_point_at_mouse(State)
      drawing.pending = {mode=State.current_drawing_mode, target_point=point_index}
      State.lines.current_drawing_index = drawing_index
      State.lines.current_drawing = drawing
        -- don't clobber
      end
      State.current_drawing_mode = 'name'
        State.previous_drawing_mode = State.current_drawing_mode
      if State.previous_drawing_mode == nil then
      end
      State.current_drawing_mode = 'move'
      drawing.pending = {mode=State.current_drawing_mode, target_point=p, target_point_index=i}
      State.lines.current_drawing_index = drawing_index
      State.lines.current_drawing = drawing
      if State.previous_drawing_mode == nil then
        State.previous_drawing_mode = State.current_drawing_mode
  elseif chord == 'C-u' and not App.mouse_down(1) then
    local drawing_index,drawing,line_cache,i,p = Drawing.select_point_at_mouse(State)
    elseif drawing.pending.mode == 'polygon' or drawing.pending.mode == 'rectangle' or drawing.pending.mode == 'square' then
      drawing.pending.center = Drawing.find_or_insert_point(drawing.points, drawing.pending.points[1].x, drawing.pending.points[1].y, State.width)
  elseif App.mouse_down(1) and chord == 'o' then
    State.current_drawing_mode = 'circle'
    local _,drawing = Drawing.current_drawing(State)
    drawing.pending.radius = round(geom.dist(center.x,center.y, mx,my))
    local mx,my = Drawing.coord(App.mouse_x()-State.left, State.width), Drawing.coord(App.mouse_y()-line_cache.starty, State.width)
  elseif chord == 'C-o' and not App.mouse_down(1) then
    State.current_drawing_mode = 'circle'
  elseif App.mouse_down(1) and chord == 'a' and State.current_drawing_mode == 'circle' then
    local _,drawing,line_cache = Drawing.current_drawing(State)
  elseif App.mouse_down(1) and chord == 'r' then
    if drawing.pending.mode == 'freehand' then
    elseif drawing.pending.mode == 'line' or drawing.pending.mode == 'manhattan' then
      if drawing.pending.vertices == nil then
        drawing.pending.vertices = {drawing.pending.p1}
      end
    elseif drawing.pending.mode == 'circle' or drawing.pending.mode == 'arc' then
      drawing.pending.vertices = {drawing.pending.center}
    end
    drawing.pending.mode = 'rectangle'
  elseif App.mouse_down(1) and chord == 's' then
    if drawing.pending.mode == 'freehand' then
    elseif drawing.pending.mode == 'line' or drawing.pending.mode == 'manhattan' then
      if drawing.pending.vertices == nil then
        drawing.pending.vertices = {drawing.pending.p1}
      end
    elseif drawing.pending.mode == 'polygon' then
      while #drawing.pending.vertices > 2 do
        table.remove(drawing.pending.vertices)
      end
    elseif drawing.pending.mode == 'rectangle' then
      -- reuse existing (1-2) vertices
    elseif drawing.pending.mode == 'circle' or drawing.pending.mode == 'arc' then
      drawing.pending.vertices = {drawing.pending.center}
    end
    drawing.pending.mode = 'square'
    table.insert(drawing.pending.vertices, j)
  elseif App.mouse_down(1) and chord == 'p' and (State.current_drawing_mode == 'rectangle' or State.current_drawing_mode == 'square') then
    local j = Drawing.find_or_insert_point(drawing.points, mx,my, State.width)
    local _,drawing,line_cache = Drawing.current_drawing(State)
    local mx,my = Drawing.coord(App.mouse_x()-State.left, State.width), Drawing.coord(App.mouse_y()-line_cache.starty, State.width)
  elseif App.mouse_down(1) and chord == 'p' and State.current_drawing_mode == 'polygon' then
    local j = Drawing.find_or_insert_point(drawing.points, mx,my, State.width)
    local _,drawing,line_cache = Drawing.current_drawing(State)
    local mx,my = Drawing.coord(App.mouse_x()-State.left, State.width), Drawing.coord(App.mouse_y()-line_cache.starty, State.width)
      drawing.pending.vertices = {Drawing.find_or_insert_point(drawing.points, drawing.pending.points[1].x, drawing.pending.points[1].y, State.width)}
    State.current_drawing_mode = 'square'
    local _,drawing = Drawing.current_drawing(State)
  elseif chord == 'C-s' and not App.mouse_down(1) then
    State.current_drawing_mode = 'square'
    elseif drawing.pending.mode == 'polygon' or drawing.pending.mode == 'square' then
      -- reuse existing (1-2) vertices
      drawing.pending.vertices = {Drawing.find_or_insert_point(drawing.points, drawing.pending.points[1].x, drawing.pending.points[1].y, State.width)}
    State.current_drawing_mode = 'rectangle'
    local _,drawing = Drawing.current_drawing(State)
  elseif chord == 'C-r' and not App.mouse_down(1) then
    State.current_drawing_mode = 'rectangle'
    elseif drawing.pending.mode == 'rectangle' or drawing.pending.mode == 'square' then
      drawing.pending.vertices = {Drawing.find_or_insert_point(drawing.points, drawing.pending.points[1].x, drawing.pending.points[1].y, State.width)}
    State.current_drawing_mode = 'polygon'
    local _,drawing = Drawing.current_drawing(State)
    State.current_drawing_mode = 'polygon'
    State.current_drawing_mode = 'manhattan'
      drawing.pending.p1 = Drawing.find_or_insert_point(drawing.points, drawing.pending.points[1].x, drawing.pending.points[1].y, State.width)
    State.current_drawing_mode = 'manhattan'
    local drawing = Drawing.select_drawing_at_mouse(State)
    State.current_drawing_mode = 'line'
      drawing.pending.p1 = Drawing.find_or_insert_point(drawing.points, drawing.pending.points[1].x, drawing.pending.points[1].y, State.width)
    State.current_drawing_mode = 'line'
    local _,drawing = Drawing.current_drawing(State)
function Drawing.keychord_pressed(State, chord)
      State.lines.current_drawing.pending = {}
      State.lines.current_drawing = nil
      elseif drawing.pending.mode == 'arc' then
        if mx >= 0 and mx < 256 and my >= 0 and my < drawing.h then
          local center = drawing.points[drawing.pending.center]
          drawing.pending.end_angle = geom.angle_with_hint(center.x,center.y, mx,my, drawing.pending.end_angle)
          table.insert(drawing.shapes, drawing.pending)
        local mx,my = Drawing.coord(x-State.left, State.width), Drawing.coord(y-line_cache.starty, State.width)
      elseif drawing.pending.mode == 'rectangle' then
        assert(#drawing.pending.vertices <= 2)
        if #drawing.pending.vertices == 2 then
          if mx >= 0 and mx < 256 and my >= 0 and my < drawing.h then
            local first = drawing.points[drawing.pending.vertices[1]]
            local second = drawing.points[drawing.pending.vertices[2]]
          local mx,my = Drawing.coord(x-State.left, State.width), Drawing.coord(y-line_cache.starty, State.width)
      elseif drawing.pending.mode == 'polygon' then
        if mx >= 0 and mx < 256 and my >= 0 and my < drawing.h then
          table.insert(drawing.shapes, drawing.pending)
          table.insert(drawing.pending.vertices, Drawing.find_or_insert_point(drawing.points, mx,my, State.width))
        local mx,my = Drawing.coord(x-State.left, State.width), Drawing.coord(y-line_cache.starty, State.width)
          local p2 = drawing.points[drawing.pending.p2]
          table.insert(drawing.shapes, drawing.pending)
          App.mouse_move(State.left+Drawing.pixels(p2.x, State.width), line_cache.starty+Drawing.pixels(p2.y, State.width))
            drawing.pending.p2 = Drawing.find_or_insert_point(drawing.points, p1.x, my, State.width)
            drawing.pending.p2 = Drawing.find_or_insert_point(drawing.points, mx, p1.y, State.width)
      elseif drawing.pending.mode == 'manhattan' then
        local p1 = drawing.points[drawing.pending.p1]
        if mx >= 0 and mx < 256 and my >= 0 and my < drawing.h then
        local mx,my = Drawing.coord(x-State.left, State.width), Drawing.coord(y-line_cache.starty, State.width)
        Drawing.smoothen(drawing.pending)
        table.insert(drawing.shapes, drawing.pending)
      elseif drawing.pending.mode == 'line' then
        if mx >= 0 and mx < 256 and my >= 0 and my < drawing.h then
          table.insert(drawing.shapes, drawing.pending)
          drawing.pending.p2 = Drawing.find_or_insert_point(drawing.points, mx,my, State.width)
        local mx,my = Drawing.coord(x-State.left, State.width), Drawing.coord(y-line_cache.starty, State.width)
    if drawing.pending then
      if drawing.pending.mode == nil then
        -- nothing pending
      elseif drawing.pending.mode == 'freehand' then
function Drawing.mouse_released(State, x,y, button)
  if State.current_drawing_mode == 'move' then
    State.current_drawing_mode = State.previous_drawing_mode
    State.previous_drawing_mode = nil
    if State.lines.current_drawing then
      State.lines.current_drawing.pending = {}
      State.lines.current_drawing = nil
  elseif State.current_drawing_mode == 'move' then
    if Drawing.in_drawing(drawing, line_cache, pmx, pmy, State.left,State.right) then
        table.insert(drawing.pending.points, {x=mx, y=my})
  local pmx, pmy = App.mouse_x(), App.mouse_y()
  local mx = Drawing.coord(pmx-State.left, State.width)
  local my = Drawing.coord(pmy-line_cache.starty, State.width)
function Drawing.update(State)
  if State.lines.current_drawing == nil then return end
  local drawing = State.lines.current_drawing
  local line_cache = State.line_cache[State.lines.current_drawing_index]
    print(State.current_drawing_mode)
  local cx = Drawing.coord(x-State.left, State.width)
  if State.current_drawing_mode == 'freehand' then
  elseif State.current_drawing_mode == 'line' or State.current_drawing_mode == 'manhattan' then
    drawing.pending = {mode=State.current_drawing_mode, p1=j}
  elseif State.current_drawing_mode == 'polygon' or State.current_drawing_mode == 'rectangle' or State.current_drawing_mode == 'square' then
    drawing.pending = {mode=State.current_drawing_mode, vertices={j}}
  elseif State.current_drawing_mode == 'circle' then
    drawing.pending = {mode=State.current_drawing_mode, center=j}
  elseif State.current_drawing_mode == 'move' then
    local j = Drawing.find_or_insert_point(drawing.points, cx, cy, State.width)
    local j = Drawing.find_or_insert_point(drawing.points, cx, cy, State.width)
    local j = Drawing.find_or_insert_point(drawing.points, cx, cy, State.width)
    drawing.pending = {mode=State.current_drawing_mode, points={{x=cx, y=cy}}}
  local cy = Drawing.coord(y-line_cache.starty, State.width)
    -- all the action is in mouse_released
    -- nothing
  elseif State.current_drawing_mode == 'name' then
function Drawing.mouse_pressed(State, drawing_index, x,y, button)
  local drawing = State.lines[drawing_index]
  local line_cache = State.line_cache[drawing_index]
function Drawing.in_drawing(drawing, line_cache, x,y, left,right)
  if line_cache.starty == nil then return false end  -- outside current page
    local cx,cy = px(center.x), py(center.y)
    love.graphics.circle('line', cx,cy, geom.dist(cx,cy, App.mouse_x(),App.mouse_y()))
    local cx,cy = px(center.x), py(center.y)
    love.graphics.line(px(first.x),py(first.y), px(second.x),py(second.y))
    love.graphics.line(px(second.x),py(second.y), px(thirdx),py(thirdy))
    love.graphics.line(px(thirdx),py(thirdy), px(fourthx),py(fourthy))
    love.graphics.line(px(fourthx),py(fourthy), px(first.x),py(first.y))
      love.graphics.line(px(first.x),py(first.y), pmx,pmy)
    love.graphics.line(px(first.x),py(first.y), px(second.x),py(second.y))
    love.graphics.line(px(second.x),py(second.y), px(thirdx),py(thirdy))
    love.graphics.line(px(thirdx),py(thirdy), px(fourthx),py(fourthy))
    love.graphics.line(px(fourthx),py(fourthy), px(first.x),py(first.y))
      love.graphics.line(px(first.x),py(first.y), pmx,pmy)
    love.graphics.line(px(prev.x),py(prev.y), pmx,pmy)
        love.graphics.line(px(prev.x),py(prev.y), px(curr.x),py(curr.y))
      love.graphics.line(px(p1.x),py(p1.y), px(p1.x),pmy)
      love.graphics.line(px(p1.x),py(p1.y), pmx,     py(p1.y))
    local p1 = drawing.points[shape.p1]
    love.graphics.line(px(p1.x),py(p1.y), pmx,pmy)
  if shape.mode == nil then
    -- nothing pending
  elseif shape.mode == 'freehand' then
    local shape_copy = deepcopy(shape)
    Drawing.smoothen(shape_copy)
    Drawing.draw_shape(drawing, shape_copy, top, left,right)
function Drawing.draw_pending_shape(drawing, top, left,right)
  local width = right-left
  local pmx,pmy = App.mouse_x(), App.mouse_y()
  local mx = Drawing.coord(pmx-left, width)
  local my = Drawing.coord(pmy-top, width)
  -- recreate pixels from coords to precisely mimic how the drawing will look
  -- after mouse_released
  pmx,pmy = px(mx), py(my)
  local function px(x) return Drawing.pixels(x, width)+left end
  local function py(y) return Drawing.pixels(y, width)+top end
    love.graphics.arc('line', 'open', px(center.x),py(center.y), Drawing.pixels(shape.radius, width), shape.start_angle, shape.end_angle, 360)
    love.graphics.circle('line', px(center.x),py(center.y), Drawing.pixels(shape.radius, width))
    -- TODO: clip
    love.graphics.line(px(prev.x),py(prev.y), px(curr.x),py(curr.y))
        love.graphics.line(px(prev.x),py(prev.y), px(curr.x),py(curr.y))
    love.graphics.line(px(p1.x),py(p1.y), px(p2.x),py(p2.y))
        love.graphics.line(px(prev.x),py(prev.y), px(point.x),py(point.y))
function Drawing.draw_shape(drawing, shape, top, left,right)
  local width = right-left
  local function px(x) return Drawing.pixels(x, width)+left end
  local function py(y) return Drawing.pixels(y, width)+top end
  App.color(Current_stroke_color)
  Drawing.draw_pending_shape(line, line_cache.starty, State.left,State.right)
        App.color(Stroke_color)
        love.graphics.circle('fill', px(p.x),py(p.y), 2)
        App.color(Focus_stroke_color)
        love.graphics.circle('line', px(p.x),py(p.y), Same_point_distance)
      if Drawing.near(p, mx,my, State.width) then
  local function px(x) return Drawing.pixels(x, State.width)+State.left end
  local function py(y) return Drawing.pixels(y, State.width)+line_cache.starty end
  for i,p in ipairs(line.points) do
    Drawing.draw_shape(line, shape, line_cache.starty, State.left,State.right)
      App.color(Stroke_color)
    if geom.on_shape(mx,my, line, shape) then
      App.color(Focus_stroke_color)
  local mx = Drawing.coord(pmx-State.left, State.width)
  local my = Drawing.coord(pmy-line_cache.starty, State.width)
    draw_help_without_mouse_pressed(State, line_index)
    if App.mouse_down(1) and love.keyboard.isDown('h') then
      draw_help_with_mouse_pressed(State, line_index)
      icon[State.previous_drawing_mode](State.right-22, line_cache.starty+4)
-- All drawings span 100% of some conceptual 'page width' and divide it up
-- into 256 parts.
  local pmx,pmy = App.mouse_x(), App.mouse_y()
    App.color(Icon_color)
    if icon[State.current_drawing_mode] then
      icon[State.current_drawing_mode](State.right-22, line_cache.starty+4)
    love.graphics.rectangle('line', State.left,line_cache.starty, State.width,Drawing.pixels(line.h, State.width))
  if pmx < State.right and pmy > line_cache.starty and pmy < line_cache.starty+Drawing.pixels(line.h, State.width) then
function Drawing.draw(State, line_index, y)
  local line = State.lines[line_index]
  local line_cache = State.line_cache[line_index]
  line_cache.starty = y

File deletion: icons.lua

BF:BFD[27.2] → [54.6587:6620]

BF:BFD[54.6620] → [54.5323:5323]

B:BD[54.5323] → [54.5324:5334]

B:BD[54.5335] → [54.5335:5370]

∅:D[66.287] → [54.5408:5526]

B:BD[54.5408] → [54.5408:5526]

B:BD[54.5560] → [54.5560:6505]

∅:D[80.205] → [54.6505:6510]

B:BD[54.6505] → [54.6505:6510]

∅:D[80.402] → [54.6510:6586]

B:BD[54.6510] → [54.6510:6586]

B:BD[54.6510] → [80.206:402]

B:BD[54.6505] → [80.6:205]

B:BD[54.5370] → [66.263:287]

B:BD[54.5334] → [118.881:882]

icon = {}
function icon.insert_drawing(x, y)
  love.graphics.rectangle('line', x,y, 12,12)
  love.graphics.line(4,y+6, 16,y+6)
  love.graphics.line(10,y, 10,y+12)
end
function icon.freehand(x, y)
  love.graphics.line(x+4,y+7,x+5,y+5)
  love.graphics.line(x+5,y+5,x+7,y+4)
  love.graphics.line(x+7,y+4,x+9,y+3)
  love.graphics.line(x+9,y+3,x+10,y+5)
  love.graphics.line(x+10,y+5,x+12,y+6)
  love.graphics.line(x+12,y+6,x+13,y+8)
  love.graphics.line(x+13,y+8,x+13,y+10)
  love.graphics.line(x+13,y+10,x+14,y+12)
  love.graphics.line(x+14,y+12,x+15,y+14)
  love.graphics.line(x+15,y+14,x+15,y+16)
end
function icon.line(x, y)
  love.graphics.line(x+4,y+2, x+16,y+18)
end
function icon.manhattan(x, y)
  love.graphics.line(x+4,y+20, x+4,y+2)
  love.graphics.line(x+4,y+2, x+10,y+2)
  love.graphics.line(x+10,y+2, x+10,y+10)
  love.graphics.line(x+10,y+10, x+18,y+10)
end
function icon.polygon(x, y)
  love.graphics.line(x+8,y+2, x+14,y+2)
  love.graphics.line(x+14,y+2, x+18,y+10)
  love.graphics.line(x+18,y+10, x+10,y+18)
  love.graphics.line(x+10,y+18, x+4,y+12)
  love.graphics.line(x+4,y+12, x+8,y+2)
end
function icon.circle(x, y)
  love.graphics.circle('line', x+10,y+10, 8)
end
function icon.square(x, y)
  love.graphics.line(x+6,y+6, x+6,y+16)
  love.graphics.line(x+6,y+16, x+16,y+16)
  love.graphics.line(x+16,y+16, x+16,y+6)
  love.graphics.line(x+16,y+6, x+6,y+6)
end
end
function icon.rectangle(x, y)
  love.graphics.line(x+4,y+8, x+4,y+16)
  love.graphics.line(x+4,y+16, x+16,y+16)
  love.graphics.line(x+16,y+16, x+16,y+8)
  love.graphics.line(x+16,y+8, x+4,y+8)
  App.color(Icon_color)

File deletion: help.lua
BF:BFD[27.2] → [54.11545:11577]
BF:BFD[54.11577] → [54.6622:6622]
∅:D[14.207] → [34.18377:18438]
B:BD[54.6732] → [34.18377:18438]
∅:D[34.18438] → [62.138:166]
B:BD[62.138] → [62.138:166]
∅:D[34.18548] → [62.282:310]
B:BD[62.282] → [62.282:310]
∅:D[34.18664] → [62.432:460]
B:BD[62.432] → [62.432:460]
∅:D[34.18762] → [62.564:592]
B:BD[62.564] → [62.564:592]
∅:D[34.18876] → [62.712:740]
B:BD[62.712] → [62.712:740]
∅:D[34.18979] → [62.849:928]
B:BD[62.849] → [62.849:928]
∅:D[34.19079] → [62.1034:1064]
B:BD[62.1034] → [62.1034:1064]
∅:D[119.530] → [54.7459:7465]
∅:D[62.1064] → [54.7459:7465]
∅:D[72.5699] → [54.7459:7465]
∅:D[31.88146] → [54.7459:7465]
B:BD[54.7459] → [54.7459:7465]
∅:D[119.563] → [54.7613:7619]
∅:D[62.1237] → [54.7613:7619]
∅:D[72.5804] → [54.7613:7619]
∅:D[31.88340] → [54.7613:7619]
B:BD[54.7613] → [54.7613:7619]
∅:D[119.596] → [54.7792:7798]
∅:D[62.1435] → [54.7792:7798]
∅:D[72.5929] → [54.7792:7798]
∅:D[31.88559] → [54.7792:7798]
B:BD[54.7792] → [54.7792:7798]
∅:D[119.629] → [54.7955:7961]
∅:D[62.1617] → [54.7955:7961]
∅:D[72.6041] → [54.7955:7961]
∅:D[31.88762] → [54.7955:7961]
B:BD[54.7955] → [54.7955:7961]
∅:D[119.662] → [80.422:428]
∅:D[62.1796] → [80.422:428]
∅:D[72.6149] → [80.422:428]
∅:D[31.88962] → [80.422:428]
B:BD[80.422] → [80.422:428]
∅:D[119.695] → [80.586:592]
∅:D[62.1979] → [80.586:592]
∅:D[72.6259] → [80.586:592]
∅:D[31.89166] → [80.586:592]
B:BD[80.586] → [80.586:592]
∅:D[119.728] → [54.8115:8121]
∅:D[62.2156] → [54.8115:8121]
∅:D[72.6366] → [54.8115:8121]
∅:D[31.89364] → [54.8115:8121]
B:BD[54.8115] → [54.8115:8121]
∅:D[120.116] → [54.8578:8583]
∅:D[121.149] → [54.8578:8583]
∅:D[14.355] → [54.8578:8583]
∅:D[67.467] → [54.8578:8583]
∅:D[122.1605] → [54.8578:8583]
∅:D[60.2120] → [54.8578:8583]
∅:D[62.2567] → [54.8578:8583]
∅:D[34.19961] → [54.8578:8583]
∅:D[31.89817] → [54.8578:8583]
B:BD[54.8578] → [54.8578:8583]
∅:D[14.548] → [34.19962:20071]
B:BD[54.8689] → [34.19962:20071]
∅:D[34.20071] → [62.2739:2767]
B:BD[62.2739] → [62.2739:2767]
∅:D[34.20137] → [62.2839:2918]
B:BD[62.2839] → [62.2839:2918]
∅:D[34.20238] → [62.3025:3151]
B:BD[62.3025] → [62.3025:3151]
∅:D[34.20337] → [62.3256:3339]
B:BD[62.3256] → [62.3256:3339]
∅:D[62.3339] → [54.9302:9347]
∅:D[31.90611] → [54.9302:9347]
B:BD[54.9302] → [54.9302:9347]
∅:D[122.2174] → [54.9561:9570]
∅:D[62.3578] → [54.9561:9570]
∅:D[72.7301] → [54.9561:9570]
∅:D[34.20531] → [54.9561:9570]
∅:D[31.90871] → [54.9561:9570]
B:BD[54.9561] → [54.9561:9570]
∅:D[122.2275] → [54.9670:9678]
∅:D[62.3685] → [54.9670:9678]
∅:D[72.7393] → [54.9670:9678]
∅:D[34.20631] → [54.9670:9678]
∅:D[31.90985] → [54.9670:9678]
B:BD[54.9670] → [54.9670:9678]
∅:D[123.982] → [54.9970:9976]
∅:D[119.1113] → [54.9970:9976]
∅:D[72.7639] → [54.9970:9976]
B:BD[54.9970] → [54.9970:9976]
∅:D[119.1207] → [54.10266:10272]
∅:D[62.5316] → [54.10266:10272]
∅:D[72.7890] → [54.10266:10272]
∅:D[31.92798] → [54.10266:10272]
B:BD[54.10266] → [54.10266:10272]
∅:D[119.1240] → [54.10440:10446]
∅:D[62.5509] → [54.10440:10446]
∅:D[72.8010] → [54.10440:10446]
∅:D[31.93012] → [54.10440:10446]
B:BD[54.10440] → [54.10440:10446]
∅:D[119.1273] → [54.10598:10604]
∅:D[62.5686] → [54.10598:10604]
∅:D[72.8117] → [54.10598:10604]
∅:D[31.93210] → [54.10598:10604]
B:BD[54.10598] → [54.10598:10604]
∅:D[119.1306] → [80.745:751]
∅:D[62.5860] → [80.745:751]
∅:D[72.8220] → [80.745:751]
∅:D[31.93405] → [80.745:751]
B:BD[80.745] → [80.745:751]
∅:D[119.1339] → [80.904:910]
∅:D[62.6038] → [80.904:910]
∅:D[72.8325] → [80.904:910]
∅:D[31.93604] → [80.904:910]
B:BD[80.904] → [80.904:910]
∅:D[119.1372] → [54.10753:10759]
∅:D[62.6210] → [54.10753:10759]
∅:D[72.8427] → [54.10753:10759]
∅:D[31.93797] → [54.10753:10759]
B:BD[54.10753] → [54.10753:10759]
∅:D[120.226] → [54.10910:10915]
∅:D[121.287] → [54.10910:10915]
∅:D[67.599] → [54.10910:10915]
∅:D[14.696] → [54.10910:10915]
∅:D[60.2245] → [54.10910:10915]
∅:D[122.3249] → [54.10910:10915]
∅:D[62.6360] → [54.10910:10915]
∅:D[34.22193] → [54.10910:10915]
∅:D[31.93961] → [54.10910:10915]
B:BD[54.10910] → [54.10910:10915]
∅:D[62.6449] → [54.10990:11019]
∅:D[31.94020] → [54.10990:11019]
B:BD[54.10990] → [54.10990:11019]
∅:D[62.6501] → [54.11064:11091]
∅:D[31.94079] → [54.11064:11091]
B:BD[54.11064] → [54.11064:11091]
∅:D[62.6558] → [54.11141:11179]
∅:D[31.94143] → [54.11141:11179]
B:BD[54.11141] → [54.11141:11179]
∅:D[62.6644] → [54.11258:11282]
∅:D[31.94236] → [54.11258:11282]
B:BD[54.11258] → [54.11258:11282]
∅:D[62.6683] → [54.11314:11544]
∅:D[31.94282] → [54.11314:11544]
B:BD[54.11314] → [54.11314:11544]
B:BD[54.11282] → [62.6645:6683]
B:BD[54.11179] → [62.6559:6644]
B:BD[54.11091] → [62.6502:6558]
B:BD[54.11019] → [62.6450:6501]
B:BD[54.10915] → [62.6361:6449]
B:BD[54.10759] → [66.375:410]
B:BD[66.410] → [14.549:696]
B:BD[80.910] → [62.6039:6088]
∅:D[34.22074] → [62.6180:6210]
B:BD[62.6180] → [62.6180:6210]
B:BD[62.6088] → [34.21989:22074]
B:BD[80.751] → [62.5861:5913]
∅:D[34.21988] → [62.6008:6038]
B:BD[62.6008] → [62.6008:6038]
B:BD[62.5913] → [34.21900:21988]
B:BD[54.10604] → [62.5687:5737]
∅:D[34.21899] → [62.5830:5860]
B:BD[62.5830] → [62.5830:5860]
B:BD[62.5737] → [34.21813:21899]
B:BD[54.10446] → [62.5510:5559]
∅:D[34.21812] → [62.5656:5686]
B:BD[62.5656] → [62.5656:5686]
B:BD[62.5559] → [34.21722:21812]
B:BD[54.10272] → [62.5317:5369]
∅:D[34.21721] → [62.5479:5509]
B:BD[62.5479] → [62.5479:5509]
B:BD[62.5369] → [34.21618:21721]
∅:D[34.21533] → [62.5093:5196]
B:BD[62.5093] → [62.5093:5196]
∅:D[34.21617] → [62.5286:5316]
B:BD[62.5286] → [62.5286:5316]
B:BD[62.5196] → [34.21534:21617]
B:BD[54.9976] → [34.21419:21533]
∅:D[62.4088] → [123.62:104]
∅:D[31.91437] → [123.62:104]
B:BD[123.62] → [123.62:104]
∅:D[34.20913] → [62.4187:4219]
B:BD[62.4187] → [62.4187:4219]
∅:D[62.4219] → [123.222:231]
∅:D[31.91582] → [123.222:231]
B:BD[123.222] → [123.222:231]
∅:D[34.21019] → [62.4332:4364]
B:BD[62.4332] → [62.4332:4364]
∅:D[34.21124] → [62.4475:4507]
B:BD[62.4475] → [62.4475:4507]
B:BD[62.4364] → [34.21020:21124]
∅:D[62.4507] → [123.495:503]
∅:D[31.91898] → [123.495:503]
B:BD[123.495] → [123.495:503]
∅:D[62.4561] → [123.550:592]
∅:D[31.91959] → [123.550:592]
B:BD[123.550] → [123.550:592]
∅:D[34.21213] → [62.4657:4689]
B:BD[62.4657] → [62.4657:4689]
∅:D[62.4689] → [123.707:716]
∅:D[31.92101] → [123.707:716]
B:BD[123.707] → [123.707:716]
∅:D[34.21316] → [62.4799:4831]
B:BD[62.4799] → [62.4799:4831]
∅:D[34.21418] → [62.4939:4971]
B:BD[62.4939] → [62.4939:4971]
B:BD[62.4831] → [34.21317:21418]
∅:D[62.4971] → [123.974:982]
∅:D[31.92411] → [123.974:982]
B:BD[123.974] → [123.974:982]
B:BD[123.716] → [34.21214:21316]
B:BD[123.592] → [34.21125:21213]
B:BD[123.503] → [62.4508:4561]
B:BD[123.231] → [34.20914:21019]
B:BD[123.104] → [34.20822:20913]
B:BD[54.9678] → [62.3686:3770]
∅:D[34.20733] → [62.3878:3908]
B:BD[62.3878] → [62.3878:3908]
∅:D[34.20821] → [62.4002:4088]
B:BD[62.4002] → [62.4002:4088]
B:BD[62.3908] → [34.20734:20821]
B:BD[62.3770] → [34.20632:20733]
B:BD[54.9570] → [34.20532:20631]
∅:D[34.20440] → [62.3449:3481]
B:BD[62.3449] → [62.3449:3481]
B:BD[62.3481] → [34.20441:20531]
B:BD[54.9347] → [34.20338:20440]
B:BD[62.3151] → [34.20239:20337]
B:BD[62.2918] → [34.20138:20238]
B:BD[62.2767] → [34.20072:20137]
∅:D[14.514] → [66.350:374]
∅:D[62.2622] → [66.350:374]
B:BD[54.8630] → [66.350:374]
B:BD[66.374] → [14.515:548]
B:BD[54.8583] → [14.356:514]
∅:D[34.19762] → [62.2275:2303]
B:BD[62.2275] → [62.2275:2303]
∅:D[34.19842] → [62.2389:2417]
B:BD[62.2389] → [62.2389:2417]
B:BD[62.2303] → [34.19763:19842]
∅:D[62.2417] → [66.314:349]
∅:D[31.89653] → [66.314:349]
B:BD[72.6670] → [66.314:349]
B:BD[66.349] → [14.208:355]
B:BD[54.8121] → [34.19651:19762]
B:BD[80.592] → [62.1980:2029]
∅:D[34.19650] → [62.2126:2156]
B:BD[62.2126] → [62.2126:2156]
B:BD[62.2029] → [34.19560:19650]
B:BD[80.428] → [62.1797:1849]
∅:D[34.19559] → [62.1949:1979]
B:BD[62.1949] → [62.1949:1979]
B:BD[62.1849] → [34.19466:19559]
B:BD[54.7961] → [62.1618:1668]
∅:D[34.19465] → [62.1766:1796]
B:BD[62.1766] → [62.1766:1796]
B:BD[62.1668] → [34.19374:19465]
B:BD[54.7798] → [62.1436:1485]
∅:D[34.19373] → [62.1587:1617]
B:BD[62.1587] → [62.1587:1617]
B:BD[62.1485] → [34.19278:19373]
B:BD[54.7619] → [62.1238:1290]
∅:D[34.19277] → [62.1405:1435]
B:BD[62.1405] → [62.1405:1435]
B:BD[62.1290] → [34.19169:19277]
B:BD[54.7465] → [62.1065:1112]
∅:D[34.19168] → [62.1207:1237]
B:BD[62.1207] → [62.1207:1237]
B:BD[62.1112] → [34.19080:19168]
B:BD[62.928] → [34.18980:19079]
B:BD[62.740] → [34.18877:18979]
B:BD[62.592] → [34.18763:18876]
B:BD[62.460] → [34.18665:18762]
B:BD[62.310] → [34.18549:18664]
B:BD[62.166] → [34.18439:18548]
∅:D[62.69] → [66.289:313]
∅:D[14.173] → [66.289:313]
B:BD[54.6673] → [66.289:313]
B:BD[66.313] → [14.174:207]
B:BD[54.6622] → [14.12:173]
```
  love.graphics.print("Things you can do:", State.left+30,y)
  y = y + State.line_height
  y = y + State.line_height
  y = y + State.line_height
  y = y + State.line_height
  y = y + State.line_height
  y = y + State.line_height
  if State.current_drawing_mode ~= 'freehand' then
    y = y + State.line_height
  end
  end
  end
  end
  end
  end
  end
end
  love.graphics.print("You're currently drawing a "..current_shape(State, drawing.pending), State.left+30,y)
  y = y + State.line_height
  y = y + State.line_height
  if State.current_drawing_mode == 'freehand' then
    y = y + State.line_height
  elseif State.current_drawing_mode == 'line' or State.current_drawing_mode == 'manhattan' then
    y = y + State.line_height
  elseif State.current_drawing_mode == 'circle' then
    if drawing.pending.mode == 'circle' then
    else
    end
  end
  end
  end
  end
  end
  end
  end
end
    return 'freehand stroke'
    return 'straight line'
    return 'horizontal/vertical line'
    return 'arc'
  else
  end
end
_bullet_indent = nil
function bullet_indent()
  if _bullet_indent == nil then
    local text = love.graphics.newText(love.graphics.getFont(), '* ')
    _bullet_indent = text:getWidth()
  end
  return _bullet_indent
end
    return State.current_drawing_mode
  elseif State.current_drawing_mode == 'circle' and shape and shape.start_angle then
  elseif State.current_drawing_mode == 'manhattan' then
  elseif State.current_drawing_mode == 'line' then
function current_shape(State, shape)
  if State.current_drawing_mode == 'freehand' then
  App.color(Help_background_color)
  love.graphics.rectangle('fill', State.left,line_cache.starty, State.width, math.max(Drawing.pixels(drawing.h, State.width),y-line_cache.starty))
  if State.current_drawing_mode ~= 'square' then
    y = y + State.line_height
    love.graphics.print("* Press 's' to switch to drawing squares", State.left+30,y)
  if State.current_drawing_mode ~= 'rectangle' then
    y = y + State.line_height
    love.graphics.print("* Press 'r' to switch to drawing rectangles", State.left+30,y)
  if State.current_drawing_mode ~= 'polygon' then
    y = y + State.line_height
    love.graphics.print("* Press 'g' to switch to drawing polygons", State.left+30,y)
  if State.current_drawing_mode ~= 'circle' then
    y = y + State.line_height
    love.graphics.print("* Press 'o' to switch to drawing circles/arcs", State.left+30,y)
  if State.current_drawing_mode ~= 'manhattan' then
    y = y + State.line_height
    love.graphics.print("* Press 'm' to switch to drawing horizontal/vertical lines", State.left+30,y)
  y = y + State.line_height
  y = y + State.line_height
  if State.current_drawing_mode ~= 'line' then
    y = y + State.line_height
    love.graphics.print("* Press 'l' to switch to drawing lines", State.left+30,y)
  love.graphics.print("* Press 'esc' then release the mouse button to cancel the current shape", State.left+30,y)
    if #drawing.pending.vertices < 2 then
      y = y + State.line_height
    else
      y = y + State.line_height
      y = y + State.line_height
      love.graphics.print("* Press 'p' to replace the second vertex of the rectangle", State.left+30,y)
    end
    if #drawing.pending.vertices < 2 then
      y = y + State.line_height
    else
      y = y + State.line_height
      y = y + State.line_height
      love.graphics.print("* Press 'p' to replace the second vertex of the square", State.left+30,y)
    end
      love.graphics.print('* Release the mouse button to finish drawing the square', State.left+30,y)
      love.graphics.print("* Press 'p' to add a vertex to the square", State.left+30,y)
  elseif State.current_drawing_mode == 'square' then
      love.graphics.print('* Release the mouse button to finish drawing the rectangle', State.left+30,y)
      love.graphics.print("* Press 'p' to add a vertex to the rectangle", State.left+30,y)
    y = y + State.line_height
  elseif State.current_drawing_mode == 'polygon' then
    y = y + State.line_height
    y = y + State.line_height
  elseif State.current_drawing_mode == 'rectangle' then
    love.graphics.print("* Press 'p' to add a vertex to the polygon", State.left+30,y)
    love.graphics.print('* Release the mouse button to finish drawing the polygon', State.left+30,y)
      love.graphics.print('* Release the mouse button to finish drawing the arc', State.left+30,y)
      y = y + State.line_height
      love.graphics.print("* Press 'a' to draw just an arc of a circle", State.left+30,y)
      love.graphics.print('* Release the mouse button to finish drawing the circle', State.left+30,y)
    love.graphics.print('* Release the mouse button to finish drawing the line', State.left+30,y)
    love.graphics.print('* Release the mouse button to finish drawing the stroke', State.left+30,y)
  love.graphics.print('Things you can do now:', State.left+30,y)
  App.color(Help_color)
  local y = line_cache.starty+10
function draw_help_with_mouse_pressed(State, drawing_index)
  local drawing = State.lines[drawing_index]
  local line_cache = State.line_cache[drawing_index]
  y = y + State.line_height
  y = y + State.line_height
  love.graphics.print("Press 'esc' now to hide this message", State.left+30,y)
  App.color(Help_background_color)
  love.graphics.rectangle('fill', State.left,line_cache.starty, State.width, math.max(Drawing.pixels(drawing.h, State.width),y-line_cache.starty))
  love.graphics.print("* Press 'ctrl+=' or 'ctrl+-' to zoom in or out, ctrl+0 to reset zoom", State.left+30,y)
  if State.current_drawing_mode ~= 'square' then
    y = y + State.line_height
    love.graphics.print("* Press 'ctrl+s' to switch to drawing squares", State.left+30,y)
  if State.current_drawing_mode ~= 'rectangle' then
    y = y + State.line_height
    love.graphics.print("* Press 'ctrl+r' to switch to drawing rectangles", State.left+30,y)
  if State.current_drawing_mode ~= 'polygon' then
    y = y + State.line_height
    love.graphics.print("* Press 'ctrl+g' to switch to drawing polygons", State.left+30,y)
  if State.current_drawing_mode ~= 'circle' then
    y = y + State.line_height
    love.graphics.print("* Press 'ctrl+o' to switch to drawing circles/arcs", State.left+30,y)
  if State.current_drawing_mode ~= 'manhattan' then
    y = y + State.line_height
    love.graphics.print("* Press 'ctrl+m' to switch to drawing horizontal/vertical lines", State.left+30,y)
  if State.current_drawing_mode ~= 'line' then
    y = y + State.line_height
    love.graphics.print("* Press 'ctrl+l' to switch to drawing lines", State.left+30,y)
    love.graphics.print("* Press 'ctrl+p' to switch to drawing freehand strokes", State.left+30,y)
  love.graphics.print("* Hover on a point or shape and press 'ctrl+d' to delete it", State.left+30,y)
  love.graphics.print("* Hover on a point and press 'ctrl+n', type a name, then press 'enter'", State.left+30,y)
  love.graphics.print("then press the mouse button to drop it", State.left+30+bullet_indent(),y)
  love.graphics.print("* Hover on a point and press 'ctrl+u' to pick it up and start moving it,", State.left+30,y)
  love.graphics.print("* Press the mouse button to start drawing a "..current_shape(State), State.left+30,y)
  App.color(Help_color)
  local y = line_cache.starty+10
function draw_help_without_mouse_pressed(State, drawing_index)
  local drawing = State.lines[drawing_index]
  local line_cache = State.line_cache[drawing_index]
```

File deletion: geom.lua

BF:BFD[27.2] → [54.15049:15081]

BF:BFD[54.15081] → [54.11579:11579]

∅:D[124.95] → [53.213:214]

B:BD[53.213] → [53.213:214]

∅:D[53.214] → [54.11597:11845]

B:BD[54.11597] → [54.11597:11845]

∅:D[80.1134] → [54.11961:12094]

B:BD[54.11961] → [54.11961:12094]

∅:D[53.407] → [54.12155:12237]

∅:D[77.5122] → [54.12155:12237]

B:BD[54.12155] → [54.12155:12237]

∅:D[77.5174] → [54.12288:13048]

B:BD[54.12288] → [54.12288:13048]

∅:D[53.441] → [54.13081:13184]

B:BD[54.13081] → [54.13081:13184]

∅:D[53.477] → [54.13215:13333]

B:BD[54.13215] → [54.13215:13333]

∅:D[53.509] → [54.13370:13451]

B:BD[54.13370] → [54.13370:13451]

∅:D[53.544] → [54.13483:13814]

B:BD[54.13483] → [54.13483:13814]

∅:D[80.1650] → [54.13814:14613]

B:BD[54.13814] → [54.13814:14613]

∅:D[77.5214] → [54.14652:15035]

B:BD[54.14652] → [54.14652:15035]

B:BD[54.14613] → [77.5175:5214]

B:BD[54.13814] → [80.1135:1650]

B:BD[54.13451] → [53.510:544]

B:BD[54.13333] → [53.478:509]

B:BD[54.13184] → [53.442:477]

B:BD[54.13048] → [53.408:441]

B:BD[54.12237] → [77.5123:5174]

B:BD[54.12094] → [53.291:407]

∅:D[125.518] → [80.1041:1134]

B:BD[54.11923] → [80.1041:1134]

B:BD[54.11845] → [125.9:240]

∅:D[53.252] → [125.283:438]

B:BD[125.283] → [125.283:438]

∅:D[53.290] → [125.510:518]

B:BD[125.510] → [125.510:518]

B:BD[125.438] → [53.253:290]

B:BD[125.240] → [53.215:252]

B:BD[54.11579] → [124.85:95]


function geom.on_shape(x,y, drawing, shape)
  if shape.mode == 'freehand' then
    return geom.on_freehand(x,y, drawing, shape)
  elseif shape.mode == 'line' then
    return geom.on_line(x,y, drawing, shape)
  elseif shape.mode == 'manhattan' then
    return geom.on_polygon(x,y, drawing, shape)
  elseif shape.mode == 'circle' then
    local center = drawing.points[shape.center]
  elseif shape.mode == 'arc' then
    local center = drawing.points[shape.center]
    if dist < shape.radius*0.95 or dist > shape.radius*1.05 then
      return false
    end
    return geom.angle_between(center.x,center.y, x,y, shape.start_angle,shape.end_angle)
  elseif shape.mode == 'deleted' then
  else
    print(shape.mode)
    assert(false)
  end
end
function geom.on_freehand(x,y, drawing, shape)
  local prev
  for _,p in ipairs(shape.points) do
    if prev then
      if geom.on_line(x,y, drawing, {p1=prev, p2=p}) then
        return true
      end
    end
    prev = p
  end
  return false
end
function geom.on_line(x,y, drawing, shape)
  local p1,p2
  if type(shape.p1) == 'number' then
    p1 = drawing.points[shape.p1]
    p2 = drawing.points[shape.p2]
  else
    p1 = shape.p1
    p2 = shape.p2
  end
  if p1.x == p2.x then
      return false
    end
    local y1,y2 = p1.y,p2.y
    if y1 > y2 then
      y1,y2 = y2,y1
    end
  end
  -- has the right slope and intercept
  local m = (p2.y - p1.y) / (p2.x - p1.x)
  local yp = p1.y + m*(x-p1.x)
    return false
  end
  -- between endpoints
  local k = (x-p1.x) / (p2.x-p1.x)
end
function geom.on_polygon(x,y, drawing, shape)
  local prev
  for _,p in ipairs(shape.vertices) do
    if prev then
      if geom.on_line(x,y, drawing, {p1=prev, p2=p}) then
        return true
      end
    end
    prev = p
  end
  return geom.on_line(x,y, drawing, {p1=shape.vertices[1], p2=shape.vertices[#shape.vertices]})
end
function geom.angle_with_hint(x1, y1, x2, y2, hint)
  local result = geom.angle(x1,y1, x2,y2)
  if hint then
    -- Smooth the discontinuity where angle goes from positive to negative.
    -- The hint is a memory of which way we drew it last time.
    while result > hint+math.pi/10 do
      result = result-math.pi*2
    end
    while result < hint-math.pi/10 do
      result = result+math.pi*2
    end
  end
  return result
end
-- result is from -π/2 to 3π/2, approximately adding math.atan2 from Lua 5.3
-- (LÖVE is Lua 5.1)
function geom.angle(x1,y1, x2,y2)
  local result = math.atan((y2-y1)/(x2-x1))
  if x2 < x1 then
    result = result+math.pi
  end
  return result
end
-- is the line between x,y and cx,cy at an angle between s and e?
function geom.angle_between(ox,oy, x,y, s,e)
  if s > e then
    s,e = e,s
  end
  -- I'm not sure this is right or ideal..
  angle = angle-math.pi*2
  if s <= angle and angle <= e then
    return true
  end
  angle = angle+math.pi*2
  if s <= angle and angle <= e then
    return true
  end
  angle = angle+math.pi*2
  return s <= angle and angle <= e
end
function geom.dist(x1,y1, x2,y2) return ((x2-x1)^2+(y2-y1)^2)^0.5 end
  local angle = geom.angle(ox,oy, x,y)
end
-- are (x3,y3) and (x4,y4) on the same side of the line between (x1,y1) and (x2,y2)
function geom.same_side(x1,y1, x2,y2, x3,y3, x4,y4)
  if x1 == x2 then
    return math.sign(x3-x1) == math.sign(x4-x1)
  end
  if y1 == y2 then
    return math.sign(y3-y1) == math.sign(y4-y1)
  end
  local m = (y2-y1)/(x2-x1)
  return math.sign(m*(x3-x1) + y1-y3) == math.sign(m*(x4-x1) + y1-y4)
end
function math.sign(x)
  if x > 0 then
    return 1
  elseif x == 0 then
    return 0
  elseif x < 0 then
    return -1
  end
  return k > -0.005 and k < 1.005
  if yp < y-2 or yp > y+2 then
    return y >= y1-2 and y <= y2+2
    if math.abs(p1.x-x) > 2 then
    local dist = geom.dist(center.x,center.y, x,y)
    local dist = geom.dist(center.x,center.y, x,y)
    return dist > shape.radius*0.95 and dist < shape.radius*1.05
  elseif shape.mode == 'polygon' or shape.mode == 'rectangle' or shape.mode == 'square' then
    local p1 = drawing.points[shape.p1]
    local p2 = drawing.points[shape.p2]
    if p1.x == p2.x then
      if x ~= p1.x then return false end
      local y1,y2 = p1.y, p2.y
      if y1 > y2 then
        y1,y2 = y2,y1
      end
    elseif p1.y == p2.y then
      if y ~= p1.y then return false end
      local x1,x2 = p1.x, p2.x
      if x1 > x2 then
        x1,x2 = x2,x1
      end
    end
      return x >= x1-2 and x <= x2+2
      return y >= y1-2 and y <= y2+2
geom = {}

Replacement in undo.lua at line 63 [104.1]

∅:D[126.295] → [104.1592:1978]

∅:D[127.1017] → [104.1592:1978]

∅:D[31.1102] → [104.1592:1978]

B:BD[104.1592] → [104.1592:1978]

B:BD[104.1978] → [16.1:239]

∅:D[16.239] → [104.2236:2296]

B:BD[104.2236] → [104.2236:2296]

    if line.mode == 'text' then
      table.insert(event.lines, {mode='text', data=line.data})
    elseif line.mode == 'drawing' then
      local points=deepcopy(line.points)
--?       print('copying', line.points, 'with', #line.points, 'points into', points)
      local shapes=deepcopy(line.shapes)
--?       print('copying', line.shapes, 'with', #line.shapes, 'shapes into', shapes)
      table.insert(event.lines, {mode='drawing', h=line.h, points=points, shapes=shapes, pending={}})
--?       table.insert(event.lines, {mode='drawing', h=line.h, points=deepcopy(line.points), shapes=deepcopy(line.shapes), pending={}})
    else
      print(line.mode)
      assert(false)
    end

[127.1017]

[104.2296]

    table.insert(event.lines, State.lines[i])

Deletion in text_tests.lua at line 15 [129.2]

∅:D[31.1623] → [128.474:604]

B:BD[128.474] → [128.474:604]

B:BD[128.604] → [39.49:95]

∅:D[39.95] → [31.1624:1660]

∅:D[34.211] → [31.1624:1660]

B:BD[128.604] → [31.1624:1660]

B:BD[31.1660] → [40.348:380]

∅:D[40.380] → [30.29:55]

B:BD[31.1660] → [30.29:55]

B:BD[30.55] → [34.212:280]

∅:D[35.77] → [128.687:738]

∅:D[34.280] → [128.687:738]

∅:D[31.1807] → [128.687:738]

B:BD[128.687] → [128.687:738]

B:BD[128.738] → [31.1808:1970]

∅:D[31.1970] → [128.874:1115]

B:BD[128.874] → [128.874:1115]

B:BD[128.1115] → [39.96:142]

∅:D[39.142] → [31.1971:2028]

∅:D[34.385] → [31.1971:2028]

B:BD[128.1115] → [31.1971:2028]

B:BD[31.2028] → [40.381:413]

∅:D[61.145] → [128.1159:1244]

∅:D[40.413] → [128.1159:1244]

∅:D[31.2114] → [128.1159:1244]

B:BD[128.1159] → [128.1159:1244]

B:BD[128.1244] → [31.2115:2147]

∅:D[31.2147] → [128.1263:1300]

B:BD[128.1263] → [128.1263:1300]

B:BD[128.1300] → [35.78:131]

∅:D[35.131] → [31.2148:2318]

B:BD[128.1338] → [31.2148:2318]

end
function test_click_to_create_drawing()
  io.write('\ntest_click_to_create_drawing')
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{}
  Text.redraw_all(Editor_state)
  edit.draw(Editor_state)
  edit.run_after_mouse_click(Editor_state, 8,Editor_state.top+8, 1)
  -- cursor skips drawing to always remain on text
  check_eq(#Editor_state.lines, 2, 'F - test_click_to_create_drawing/#lines')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_click_to_create_drawing/cursor')
end
function test_backspace_to_delete_drawing()
  io.write('\ntest_backspace_to_delete_drawing')
  -- display a drawing followed by a line of text (you shouldn't ever have a drawing right at the end)
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'```lines', '```', ''}
  Text.redraw_all(Editor_state)
  -- cursor is on text as always (outside tests this will get initialized correctly)
  Editor_state.cursor1.line = 2
  -- backspacing deletes the drawing
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(#Editor_state.lines, 1, 'F - test_backspace_to_delete_drawing/#lines')
  check_eq(Editor_state.cursor1.line, 1, 'F - test_backspace_to_delete_drawing/cursor')

Replacement in text_tests.lua at line 604 [129.2]

B:BD[31.13730] → [31.13730:13840]

  check_eq(Editor_state.lines[1].data, 'abc', 'F - test_cursor_movement_without_shift_resets_selection/data')

[31.13730]

[130.2]

  check_eq(Editor_state.lines[1], 'abc', 'F - test_cursor_movement_without_shift_resets_selection/data')

Replacement in text_tests.lua at line 622 [129.2]

B:BD[131.452] → [31.14134:14215]

  check_eq(Editor_state.lines[1].data, 'xbc', 'F - test_edit_deletes_selection')

[131.452]

[132.2]

  check_eq(Editor_state.lines[1], 'xbc', 'F - test_edit_deletes_selection')

Replacement in text_tests.lua at line 645 [129.2]

B:BD[31.14601] → [31.14601:14702]

  check_eq(Editor_state.lines[1].data, 'Dbc', 'F - test_edit_with_shift_key_deletes_selection/data')

[31.14601]

[133.2]

  check_eq(Editor_state.lines[1], 'Dbc', 'F - test_edit_with_shift_key_deletes_selection/data')

Replacement in text_tests.lua at line 683 [129.2]

B:BD[134.451] → [31.15370:15436]

  check_eq(Editor_state.lines[1].data, 'bc', 'F - test_cut/data')

[134.451]

[134.504]

  check_eq(Editor_state.lines[1], 'bc', 'F - test_cut/data')

Replacement in text_tests.lua at line 704 [129.2]

B:BD[134.1068] → [31.15737:15823]

  check_eq(Editor_state.lines[1].data, 'xyzdef', 'F - test_paste_replaces_selection')

[134.1068]

[131.520]

  check_eq(Editor_state.lines[1], 'xyzdef', 'F - test_paste_replaces_selection')

Replacement in text_tests.lua at line 730 [129.2]

B:BD[31.16335] → [31.16335:16428]

  check_eq(Editor_state.lines[1].data, 'ahi', 'F - test_deleting_selection_may_scroll/data')

[31.16335]

[135.1008]

  check_eq(Editor_state.lines[1], 'ahi', 'F - test_deleting_selection_may_scroll/data')

Replacement in text_tests.lua at line 796 [129.2]

B:BD[31.18093] → [31.18093:18284]

  check_eq(Editor_state.lines[1].data, '', 'F - test_insert_newline_at_start_of_line/data:1')
  check_eq(Editor_state.lines[2].data, 'abc', 'F - test_insert_newline_at_start_of_line/data:2')

[31.18093]

[129.4366]

  check_eq(Editor_state.lines[1], '', 'F - test_insert_newline_at_start_of_line/data:1')
  check_eq(Editor_state.lines[2], 'abc', 'F - test_insert_newline_at_start_of_line/data:2')

Deletion in text_tests.lua at line 967 [129.2]

B:BD[129.7115] → [129.7115:7255]

B:BD[129.7255] → [58.2:29]

B:BD[58.29] → [34.7521:7589]

B:BD[34.7589] → [39.2352:2398]

∅:D[39.2398] → [31.24425:24493]

∅:D[34.7693] → [31.24425:24493]

B:BD[31.24425] → [31.24425:24493]

B:BD[31.24493] → [40.2315:2551]

∅:D[40.2551] → [31.24580:24802]

B:BD[31.24580] → [31.24580:24802]

B:BD[31.24802] → [33.2:80]

∅:D[33.80] → [129.7779:7946]

∅:D[136.85] → [129.7779:7946]

∅:D[58.170] → [129.7779:7946]

∅:D[31.24893] → [129.7779:7946]

B:BD[129.7779] → [129.7779:7946]

B:BD[129.7946] → [30.1536:1562]

B:BD[30.1562] → [34.7694:7723]

∅:D[34.7723] → [129.7982:8222]

∅:D[31.24930] → [129.7982:8222]

B:BD[129.7982] → [129.7982:8222]

B:BD[129.8222] → [35.3759:3811]

∅:D[35.3811] → [31.24931:25107]

B:BD[129.8259] → [31.24931:25107]

B:BD[31.25107] → [34.7724:7764]

∅:D[34.7764] → [129.8443:8517]

∅:D[31.25154] → [129.8443:8517]

B:BD[129.8443] → [129.8443:8517]

end
function test_pagedown_skips_drawings()
  io.write('\ntest_pagedown_skips_drawings')
  -- some lines of text with a drawing intermixed
  local drawing_width = 50
  App.screen.init{width=Editor_state.left+drawing_width, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc',               -- height 15
                                  '```lines', '```',   -- height 25
                                  'def',               -- height 15
                                  'ghi'}               -- height 15
  Text.redraw_all(Editor_state)
  check_eq(Editor_state.lines[2].mode, 'drawing', 'F - test_pagedown_skips_drawings/baseline/lines')
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  local drawing_height = Drawing_padding_height + drawing_width/2  -- default
  -- initially the screen displays the first line and the drawing
  -- 15px margin + 15px line1 + 10px margin + 25px drawing + 10px margin = 75px < screen height 80px
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'abc', 'F - test_pagedown_skips_drawings/baseline/screen:1')
  -- after pagedown the screen draws the drawing up top
  -- 15px margin + 10px margin + 25px drawing + 10px margin + 15px line3 = 75px < screen height 80px
  edit.run_after_keychord(Editor_state, 'pagedown')
  check_eq(Editor_state.screen_top1.line, 2, 'F - test_pagedown_skips_drawings/screen_top')
  check_eq(Editor_state.cursor1.line, 3, 'F - test_pagedown_skips_drawings/cursor')
  y = Editor_state.top + drawing_height
  App.screen.check(y, 'def', 'F - test_pagedown_skips_drawings/screen:1')

Replacement in text_tests.lua at line 1761 [129.2]

∅:D[35.5518] → [31.47162:47252]

B:BD[128.2575] → [31.47162:47252]

  check_eq(Editor_state.lines[1].data, 'abcdef', "F - test_backspace_past_line_boundary")

[35.5518]

[129.35921]

  check_eq(Editor_state.lines[1], 'abcdef', "F - test_backspace_past_line_boundary")

Replacement in text_tests.lua at line 1778 [129.2]

∅:D[35.5572] → [31.47558:47645]

B:BD[129.36543] → [31.47558:47645]

  check_eq(Editor_state.lines[1].data, 'bc', "F - test_backspace_over_selection/data")

[35.5572]

[129.36617]

  check_eq(Editor_state.lines[1], 'bc', "F - test_backspace_over_selection/data")

Replacement in text_tests.lua at line 1797 [129.2]

∅:D[35.5626] → [31.48220:48315]

B:BD[129.37369] → [31.48220:48315]

  check_eq(Editor_state.lines[1].data, 'bc', "F - test_backspace_over_selection_reverse/data")

[35.5626]

[129.37451]

  check_eq(Editor_state.lines[1], 'bc', "F - test_backspace_over_selection_reverse/data")

Replacement in text_tests.lua at line 1816 [129.2]

∅:D[35.5680] → [31.48914:49104]

B:BD[129.38262] → [31.48914:49104]

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

[35.5680]

[129.38426]

  check_eq(Editor_state.lines[1], 'akl', "F - test_backspace_over_multiple_lines/data:1")
  check_eq(Editor_state.lines[2], 'mno', "F - test_backspace_over_multiple_lines/data:2")

Replacement in text_tests.lua at line 1836 [129.2]

∅:D[35.5734] → [31.49694:49876]

B:BD[129.39172] → [31.49694:49876]

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

[35.5734]

[129.39328]

  check_eq(Editor_state.lines[1], 'a', "F - test_backspace_to_start_of_line/data:1")
  check_eq(Editor_state.lines[2], 'def', "F - test_backspace_to_start_of_line/data:2")

Replacement in text_tests.lua at line 1856 [129.2]

∅:D[35.5788] → [31.50457:50639]

B:BD[129.40076] → [31.50457:50639]

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

[35.5788]

[129.40232]

  check_eq(Editor_state.lines[1], 'abc', "F - test_backspace_to_start_of_line/data:1")
  check_eq(Editor_state.lines[2], 'f', "F - test_backspace_to_start_of_line/data:2")

Replacement in text_tests.lua at line 1953 [129.2]

∅:D[35.6032] → [31.53741:53832]

B:BD[137.412] → [31.53741:53832]

  check_eq(Editor_state.lines[1].data, 'xbc', 'F - test_undo_restores_selection/baseline')

[35.6032]

[31.53832]

  check_eq(Editor_state.lines[1], 'xbc', 'F - test_undo_restores_selection/baseline')

Replacement in text_tests.lua at line 1967 [129.2]

B:BD[138.140] → [139.2:76]

  Editor_state.lines = load_array{'```lines', '```', 'def', 'ghi', 'deg'}

[138.140]

[138.202]

  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'deg'}

Replacement in text.lua at line 53 [141.1]

B:BD[140.458] → [140.458:608]

            if State.lines[State.cursor1.line].data:sub(State.cursor1.pos, State.cursor1.pos+utf8.len(State.search_term)-1) == State.search_term then

[140.458]

[138.1429]

            if State.lines[State.cursor1.line]:sub(State.cursor1.pos, State.cursor1.pos+utf8.len(State.search_term)-1) == State.search_term then

Replacement in text.lua at line 95 [141.1]
B:BD[142.124] → [142.124:168]
```
  for frag in line.data:gmatch('%S*%s*') do
```
[142.124]
[143.682]
```
  for frag in line:gmatch('%S*%s*') do
```

Replacement in text.lua at line 145 [141.1]

B:BD[144.79] → [144.79:344]

  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)

[144.79]

[145.3]

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

Replacement in text.lua at line 185 [141.1]

∅:D[127.1511] → [146.1388:1576]

B:BD[146.1388] → [146.1388:1576]

      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)

[127.1511]

[77.2256]

      local byte_start = utf8.offset(State.lines[State.cursor1.line], State.cursor1.pos-1)
      local byte_end = utf8.offset(State.lines[State.cursor1.line], State.cursor1.pos)

Replacement in text.lua at line 189 [141.1]

B:BD[77.2306] → [146.1577:1752]

          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)

[77.2306]

[77.2442]

          State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_start-1)..string.sub(State.lines[State.cursor1.line], byte_end)

Replacement in text.lua at line 191 [141.1]

B:BD[77.2455] → [146.1753:1868]

          State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)

[77.2455]

[77.2544]

          State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_start-1)

Replacement in text.lua at line 197 [141.1]

∅:D[127.1585] → [146.2023:2145]

B:BD[146.2023] → [146.2023:2145]

B:BD[146.2145] → [147.105:166]

∅:D[147.166] → [77.2728:2761]

∅:D[146.2145] → [77.2728:2761]

∅:D[148.2527] → [77.2728:2761]

∅:D[40.4205] → [77.2728:2761]

∅:D[31.59583] → [77.2728:2761]

B:BD[77.2728] → [77.2728:2761]

B:BD[77.2761] → [146.2146:2405]

B:BD[146.2405] → [147.167:226]

∅:D[147.226] → [77.2948:2958]

∅:D[146.2405] → [77.2948:2958]

∅:D[148.2767] → [77.2948:2958]

∅:D[40.4270] → [77.2948:2958]

∅:D[31.59920] → [77.2948:2958]

B:BD[77.2948] → [77.2948:2958]

      if State.lines[State.cursor1.line-1].mode == 'drawing' then
        table.remove(State.lines, State.cursor1.line-1)
        table.remove(State.line_cache, State.cursor1.line-1)
      else
        -- join lines
        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)
        table.remove(State.line_cache, State.cursor1.line)
      end

[127.1585]

[146.2406]

      -- join lines
      State.cursor1.pos = utf8.len(State.lines[State.cursor1.line-1])+1
      State.lines[State.cursor1.line-1] = State.lines[State.cursor1.line-1]..State.lines[State.cursor1.line]
      table.remove(State.lines, State.cursor1.line)
      table.remove(State.line_cache, State.cursor1.line)

Replacement in text.lua at line 225 [141.1]

B:BD[126.1869] → [146.3061:3141]

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

[126.1869]

[127.1676]

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

Replacement in text.lua at line 230 [141.1]

B:BD[149.8554] → [146.3253:3521]

    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)

[149.8554]

[77.3265]

    if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line]) then
      local byte_start = utf8.offset(State.lines[State.cursor1.line], State.cursor1.pos)
      local byte_end = utf8.offset(State.lines[State.cursor1.line], State.cursor1.pos+1)

Replacement in text.lua at line 235 [141.1]

B:BD[77.3315] → [146.3522:3697]

          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)

[77.3315]

[77.3451]

          State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_start-1)..string.sub(State.lines[State.cursor1.line], byte_end)

Replacement in text.lua at line 237 [141.1]

B:BD[77.3464] → [146.3698:3813]

          State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_start-1)

[77.3464]

[77.3553]

          State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_start-1)

Replacement in text.lua at line 242 [141.1]

B:BD[146.3907] → [40.4271:4334]

∅:D[40.4334] → [77.3754:3776]

B:BD[77.3754] → [77.3754:3776]

B:BD[77.3776] → [146.4030:4154]

∅:D[148.3646] → [77.3904:3914]

∅:D[146.4210] → [77.3904:3914]

∅:D[31.62131] → [77.3904:3914]

B:BD[77.3904] → [77.3904:3914]

      if State.lines[State.cursor1.line+1].mode == 'text' then
        -- join lines
        State.lines[State.cursor1.line].data = State.lines[State.cursor1.line].data..State.lines[State.cursor1.line+1].data
      end

[146.3907]

[40.4335]

      -- join lines
      State.lines[State.cursor1.line] = State.lines[State.cursor1.line]..State.lines[State.cursor1.line+1]

Replacement in text.lua at line 336 [141.1]

B:BD[144.2057] → [144.2057:2281]

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

[144.2057]

[147.287]

  local byte_offset = Text.offset(State.lines[State.cursor1.line], State.cursor1.pos)
  table.insert(State.lines, State.cursor1.line+1, string.sub(State.lines[State.cursor1.line], byte_offset))

Replacement in text.lua at line 339 [141.1]

∅:D[147.346] → [144.2281:2389]

∅:D[40.4518] → [144.2281:2389]

B:BD[144.2281] → [144.2281:2389]

  State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)

[147.346]

[145.184]

  State.lines[State.cursor1.line] = string.sub(State.lines[State.cursor1.line], 1, byte_offset-1)

Replacement in text.lua at line 354 [141.1]

B:BD[144.2828] → [144.2828:2993]

B:BD[144.2993] → [33.82:188]

∅:D[67.115] → [150.555:563]

∅:D[136.168] → [150.555:563]

∅:D[33.188] → [150.555:563]

∅:D[144.3092] → [150.555:563]

∅:D[31.66841] → [150.555:563]

B:BD[150.555] → [150.555:563]

    if State.lines[State.screen_top1.line].mode == 'text' then
      y = y - State.line_height
    elseif State.lines[State.screen_top1.line].mode == 'drawing' then
      y = y - Drawing_padding_height - Drawing.pixels(State.lines[State.screen_top1.line].h, State.width)
    end

[144.2828]

[151.486]

    y = y - State.line_height

Deletion in text.lua at line 391 [141.1]
∅:D[151.816] → [144.3868:3925]
B:BD[144.3868] → [144.3868:3925]
```
  assert(State.lines[State.cursor1.line].mode == 'text')
```

Replacement in text.lua at line 396 [141.1]

B:BD[152.443] → [144.4030:4077]

∅:D[144.4077] → [152.484:559]

∅:D[31.67955] → [152.484:559]

B:BD[152.484] → [152.484:559]

B:BD[152.559] → [144.4078:4136]

∅:D[144.4136] → [152.611:657]

∅:D[31.68021] → [152.611:657]

B:BD[152.611] → [152.611:657]

B:BD[152.657] → [144.4137:4182]

B:BD[144.4182] → [153.208:282]

∅:D[154.251] → [152.826:937]

∅:D[153.282] → [152.826:937]

∅:D[155.365] → [152.826:937]

∅:D[151.1023] → [152.826:937]

∅:D[144.4275] → [152.826:937]

∅:D[31.68181] → [152.826:937]

B:BD[156.779] → [152.826:937]

B:BD[152.937] → [147.347:450]

∅:D[147.450] → [152.1023:1264]

∅:D[144.4374] → [152.1023:1264]

∅:D[40.4627] → [152.1023:1264]

∅:D[31.68294] → [152.1023:1264]

B:BD[152.1023] → [152.1023:1264]

B:BD[152.1264] → [144.4375:4655]

∅:D[144.4655] → [152.1508:1520]

∅:D[31.68617] → [152.1508:1520]

B:BD[152.1508] → [152.1508:1520]

B:BD[152.1520] → [144.4656:4882]

B:BD[144.4882] → [151.1024:1138]

∅:D[157.99] → [152.1691:1705]

∅:D[151.1138] → [152.1691:1705]

∅:D[144.4990] → [152.1691:1705]

∅:D[31.68994] → [152.1691:1705]

B:BD[152.1691] → [152.1691:1705]

    local new_cursor_line = State.cursor1.line
    while new_cursor_line > 1 do
      new_cursor_line = new_cursor_line-1
      if State.lines[new_cursor_line].mode == 'text' then
--?         print('found previous text line')
        State.cursor1.line = new_cursor_line
        Text.populate_screen_line_starting_pos(State, State.cursor1.line)
        -- previous text line found, pick its final screen line
--?         print('has multiple screen lines')
        local screen_line_starting_pos = State.line_cache[State.cursor1.line].screen_line_starting_pos
--?         print(#screen_line_starting_pos)
        screen_line_starting_pos = screen_line_starting_pos[#screen_line_starting_pos]
--?         print('previous screen line starts at pos '..tostring(screen_line_starting_pos)..' of its line')
        if State.screen_top1.line > State.cursor1.line then
          State.screen_top1.line = State.cursor1.line
          State.screen_top1.pos = screen_line_starting_pos
--?           print('pos of top of screen is also '..tostring(State.screen_top1.pos)..' of the same line')
        end
        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)
        State.cursor1.pos = screen_line_starting_pos + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1
        break

[152.443]

[158.2443]

    if State.cursor1.line > 1 then
      local new_cursor_line = State.cursor1.line-1
--?       print('found previous text line')
      State.cursor1.line = new_cursor_line
      Text.populate_screen_line_starting_pos(State, State.cursor1.line)
      -- previous text line found, pick its final screen line
--?       print('has multiple screen lines')
      local screen_line_starting_pos = State.line_cache[State.cursor1.line].screen_line_starting_pos
--?       print(#screen_line_starting_pos)
      screen_line_starting_pos = screen_line_starting_pos[#screen_line_starting_pos]
--?       print('previous screen line starts at pos '..tostring(screen_line_starting_pos)..' of its line')
      if State.screen_top1.line > State.cursor1.line then
        State.screen_top1.line = State.cursor1.line
        State.screen_top1.pos = screen_line_starting_pos
--?         print('pos of top of screen is also '..tostring(State.screen_top1.pos)..' of the same line')

Insertion in text.lua at line 412 [141.1]

[158.2453]

[152.1706]

      local screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line], screen_line_starting_pos)
      local s = string.sub(State.lines[State.cursor1.line], screen_line_starting_byte_offset)
      State.cursor1.pos = screen_line_starting_pos + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1

Replacement in text.lua at line 429 [141.1]

B:BD[152.2441] → [144.5473:5703]

    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)

[152.2441]

[151.1139]

    local new_screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line], new_screen_line_starting_pos)
    local s = string.sub(State.lines[State.cursor1.line], new_screen_line_starting_byte_offset)

Deletion in text.lua at line 437 [141.1]
∅:D[151.1280] → [144.5916:5973]
B:BD[144.5916] → [144.5916:5973]
```
  assert(State.lines[State.cursor1.line].mode == 'text')
```

Replacement in text.lua at line 441 [141.1]

B:BD[152.3017] → [144.6133:6224]

∅:D[144.6224] → [152.3096:3138]

∅:D[31.70385] → [152.3096:3138]

B:BD[152.3096] → [152.3096:3138]

B:BD[152.3138] → [144.6225:6328]

B:BD[144.6328] → [151.1332:1450]

∅:D[151.1450] → [144.6440:6477]

B:BD[144.6440] → [144.6440:6477]

∅:D[144.6477] → [152.3342:3356]

∅:D[31.70687] → [152.3342:3356]

B:BD[152.3342] → [152.3342:3356]

∅:D[152.3356] → [158.2689:2699]

B:BD[158.2689] → [158.2689:2699]

    local new_cursor_line = State.cursor1.line
    while new_cursor_line < #State.lines do
      new_cursor_line = new_cursor_line+1
      if State.lines[new_cursor_line].mode == 'text' then
        State.cursor1.line = new_cursor_line
        State.cursor1.pos = Text.nearest_cursor_pos(State.lines[State.cursor1.line].data, State.cursor_x, State.left)
--?         print(State.cursor1.pos)
        break
      end

[152.3017]

[159.1313]

    if State.cursor1.line < #State.lines then
      local new_cursor_line = State.cursor1.line+1
      State.cursor1.line = new_cursor_line
      State.cursor1.pos = Text.nearest_cursor_pos(State.lines[State.cursor1.line], State.cursor_x, State.left)
--?       print(State.cursor1.pos)

Replacement in text.lua at line 463 [141.1]

B:BD[152.4338] → [144.6881:7111]

    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)

[152.4338]

[151.1606]

    local new_screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line], new_screen_line_starting_pos)
    local s = string.sub(State.lines[State.cursor1.line], new_screen_line_starting_byte_offset)

Replacement in text.lua at line 484 [141.1]

∅:D[151.1805] → [144.7778:7851]

B:BD[144.7778] → [144.7778:7851]

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

[151.1805]

[151.1806]

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

Replacement in text.lua at line 498 [141.1]

B:BD[160.916] → [144.7991:8079]

    if Text.match(State.lines[State.cursor1.line].data, State.cursor1.pos-1, '%S') then

[160.916]

[160.986]

    if Text.match(State.lines[State.cursor1.line], State.cursor1.pos-1, '%S') then

Replacement in text.lua at line 510 [141.1]

B:BD[144.8150] → [144.8150:8238]

    if Text.match(State.lines[State.cursor1.line].data, State.cursor1.pos-1, '%s') then

[144.8150]

[152.5221]

    if Text.match(State.lines[State.cursor1.line], State.cursor1.pos-1, '%s') then

Replacement in text.lua at line 519 [141.1]

B:BD[160.1178] → [144.8285:8364]

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

[160.1178]

[160.1239]

    if State.cursor1.pos > utf8.len(State.lines[State.cursor1.line]) then

Replacement in text.lua at line 522 [141.1]

B:BD[160.1259] → [144.8365:8451]

    if Text.match(State.lines[State.cursor1.line].data, State.cursor1.pos, '%S') then

[160.1259]

[160.1327]

    if Text.match(State.lines[State.cursor1.line], State.cursor1.pos, '%S') then

Replacement in text.lua at line 529 [141.1]

∅:D[161.148] → [144.8452:8531]

B:BD[162.35] → [144.8452:8531]

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

[161.148]

[160.1447]

    if State.cursor1.pos > utf8.len(State.lines[State.cursor1.line]) then

Replacement in text.lua at line 532 [141.1]

B:BD[160.1467] → [144.8532:8618]

    if Text.match(State.lines[State.cursor1.line].data, State.cursor1.pos, '%s') then

[160.1467]

[152.5516]

    if Text.match(State.lines[State.cursor1.line], State.cursor1.pos, '%s') then

Deletion in text.lua at line 551 [141.1]
∅:D[151.2106] → [161.188:245]
B:BD[161.188] → [161.188:245]
```
  assert(State.lines[State.cursor1.line].mode == 'text')
```

Replacement in text.lua at line 553 [141.1]

∅:D[161.321] → [163.171:178]

∅:D[31.73224] → [163.171:178]

B:BD[163.171] → [163.171:178]

B:BD[163.178] → [161.322:369]

∅:D[161.369] → [163.219:294]

∅:D[31.73279] → [163.219:294]

B:BD[163.219] → [163.219:294]

B:BD[163.294] → [161.370:552]

∅:D[161.552] → [163.446:470]

∅:D[31.73497] → [163.446:470]

B:BD[163.446] → [163.446:470]

B:BD[163.560] → [163.560:568]

  else
    local new_cursor_line = State.cursor1.line
    while new_cursor_line > 1 do
      new_cursor_line = new_cursor_line-1
      if State.lines[new_cursor_line].mode == 'text' then
        State.cursor1.line = new_cursor_line
        State.cursor1.pos = utf8.len(State.lines[State.cursor1.line].data) + 1
        break
      end
    end

[161.321]

[164.6550]

  elseif State.cursor1.line > 1 then
    State.cursor1.line = State.cursor1.line-1
    State.cursor1.pos = utf8.len(State.lines[State.cursor1.line]) + 1

Replacement in text.lua at line 572 [141.1]

B:BD[161.823] → [161.823:958]

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

[161.823]

[161.958]

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

Replacement in text.lua at line 574 [141.1]

∅:D[161.1002] → [163.738:745]

∅:D[31.73906] → [163.738:745]

B:BD[163.738] → [163.738:745]

B:BD[163.745] → [161.1003:1097]

∅:D[161.1097] → [163.827:869]

∅:D[31.74015] → [163.827:869]

B:BD[163.827] → [163.827:869]

B:BD[163.869] → [161.1098:1231]

∅:D[161.1231] → [163.984:1008]

∅:D[31.74170] → [163.984:1008]

B:BD[163.984] → [163.984:1008]

B:BD[163.1101] → [163.1101:1109]

  else
    local new_cursor_line = State.cursor1.line
    while new_cursor_line <= #State.lines-1 do
      new_cursor_line = new_cursor_line+1
      if State.lines[new_cursor_line].mode == 'text' then
        State.cursor1.line = new_cursor_line
        State.cursor1.pos = 1
        break
      end
    end

[161.1002]

[164.6913]

  elseif State.cursor1.line <= #State.lines-1 then
    State.cursor1.line = State.cursor1.line+1
    State.cursor1.pos = 1

Replacement in text.lua at line 599 [141.1]
∅:D[151.2683] → [34.16712:16734]
B:BD[165.2263] → [34.16712:16734]
∅:D[34.16734] → [165.2292:2397]
B:BD[165.2292] → [165.2292:2397]
∅:D[165.2397] → [166.166:186]
∅:D[148.6763] → [166.166:186]
∅:D[31.74994] → [166.166:186]
B:BD[166.166] → [166.166:186]
B:BD[166.186] → [165.2398:2448]
B:BD[165.2448] → [33.189:289]
∅:D[67.222] → [165.2541:2589]
∅:D[33.289] → [165.2541:2589]
B:BD[165.2541] → [165.2541:2589]
∅:D[165.2589] → [166.220:287]
∅:D[148.6800] → [166.220:287]
∅:D[31.75228] → [166.220:287]
B:BD[166.220] → [166.220:287]
B:BD[166.287] → [165.2590:2737]
B:BD[165.2737] → [147.937:976]
∅:D[147.976] → [166.402:408]
∅:D[165.2737] → [166.402:408]
∅:D[40.5183] → [166.402:408]
∅:D[31.75411] → [166.402:408]
B:BD[166.402] → [166.402:408]
B:BD[166.408] → [165.2738:2861]
```
  local y = State.top
  while State.cursor1.line <= #State.lines do
    if State.lines[State.cursor1.line].mode == 'text' then
      break
    end
--?     print('cursor skips', State.cursor1.line)
    y = y + Drawing_padding_height + Drawing.pixels(State.lines[State.cursor1.line].h, State.width)
    State.cursor1.line = State.cursor1.line + 1
  end
  -- hack: insert a text line at bottom of file if necessary
  if State.cursor1.line > #State.lines then
    assert(State.cursor1.line == #State.lines+1)
    table.insert(State.lines, {mode='text', data=''})
    table.insert(State.line_cache, {})
  end
--?   print(y, App.screen.height, App.screen.height-State.line_height)
  if y > App.screen.height - State.line_height then
```
[151.2683]
[167.1554]
```
  if State.top > App.screen.height - State.line_height then
```
Replacement in text.lua at line 615 [141.1]
B:BD[168.394] → [165.3259:3369]
B:BD[165.3369] → [34.16735:16767]
∅:D[169.1424] → [168.545:585]
∅:D[165.3408] → [168.545:585]
∅:D[34.16767] → [168.545:585]
∅:D[31.76011] → [168.545:585]
B:BD[168.545] → [168.545:585]
∅:D[168.585] → [170.767:776]
B:BD[170.767] → [170.767:776]
B:BD[170.776] → [168.586:614]
B:BD[168.614] → [165.3409:3466]
∅:D[165.3466] → [168.665:767]
∅:D[31.76076] → [168.665:767]
B:BD[168.665] → [168.665:767]
B:BD[168.767] → [33.290:387]
∅:D[67.326] → [34.16768:16800]
∅:D[33.387] → [34.16768:16800]
B:BD[165.3557] → [34.16768:16800]
∅:D[169.1458] → [168.857:946]
∅:D[165.3596] → [168.857:946]
∅:D[34.16800] → [168.857:946]
∅:D[31.76227] → [168.857:946]
B:BD[168.857] → [168.857:946]
```
    if top2.screen_line > 1 or State.lines[top2.line-1].mode == 'text' then
      local h = State.line_height
      if y - h < State.top then
        break
      end
      y = y - h
    else
      assert(top2.line > 1)
      assert(State.lines[top2.line-1].mode == 'drawing')
      -- We currently can't draw partial drawings, so either skip it entirely
      -- or not at all.
      local h = Drawing_padding_height + Drawing.pixels(State.lines[top2.line-1].h, State.width)
      if y - h < State.top then
        break
      end
--?       print('skipping drawing of height', h)
      y = y - h
```
[168.394]
[166.875]
```
    local h = State.line_height
    if y - h < State.top then
      break
```
Insertion in text.lua at line 619 [141.1]
[166.883]
[151.2833]
```
    y = y - h
```

Replacement in text.lua at line 650 [141.1]

∅:D[40.6001] → [171.1554:1648]

B:BD[171.1554] → [171.1554:1648]

∅:D[172.836] → [173.910:1037]

∅:D[171.1648] → [173.910:1037]

B:BD[173.910] → [173.910:1037]

    local screen_line_starting_byte_offset = Text.offset(line.data, screen_line_starting_pos)
--?     print('iter', y, screen_line_index, screen_line_starting_pos, string.sub(line.data, screen_line_starting_byte_offset))

[40.6001]

[165.4121]

    local screen_line_starting_byte_offset = Text.offset(line, screen_line_starting_pos)
--?     print('iter', y, screen_line_index, screen_line_starting_pos, string.sub(line, screen_line_starting_byte_offset))

Replacement in text.lua at line 661 [141.1]

B:BD[174.1679] → [174.1679:1751]

      local s = string.sub(line.data, screen_line_starting_byte_offset)

[175.538]

[151.3151]

      local s = string.sub(line, screen_line_starting_byte_offset)

Replacement in text.lua at line 674 [141.1]
∅:D[40.6333] → [176.1146:1203]
B:BD[176.1146] → [176.1146:1203]
```
  local start_offset = Text.offset(line.data, start_pos)
```
[40.6333]
[176.1203]
```
  local start_offset = Text.offset(line, start_pos)
```

Replacement in text.lua at line 678 [141.1]

∅:D[40.6451] → [176.1328:1466]

B:BD[176.1328] → [176.1328:1466]

    local past_end_offset = Text.offset(line.data, past_end_pos)
    screen_line = string.sub(line.data, start_offset, past_end_offset-1)

[40.6451]

[176.1466]

    local past_end_offset = Text.offset(line, past_end_pos)
    screen_line = string.sub(line, start_offset, past_end_offset-1)

Replacement in text.lua at line 681 [141.1]

B:BD[176.1473] → [176.1473:1524]

    screen_line = string.sub(line.data, start_pos)

[176.1473]

[176.1524]

    screen_line = string.sub(line, start_pos)

Deletion in text.lua at line 784 [141.1]
B:BD[20.34] → [20.34:142]
∅:D[20.142] → [177.103:109]
B:BD[177.103] → [177.103:109]
```
  if State.lines[loc1.line].mode == 'drawing' then
    return {line=loc1.line, screen_line=1, screen_pos=1}
  end
```

Deletion in text.lua at line 845 [141.1]

B:BD[20.897] → [20.897:1013]

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

Deletion in text.lua at line 854 [141.1]
B:BD[153.712] → [21.3:44]
```
  if line.mode ~= 'text' then return end
```

Replacement in select.lua at line 56 [129.43980]

B:BD[178.242] → [172.1160:1309]

    local lo_offset = Text.offset(line.data, lo)
    local hi_offset = Text.offset(line.data, hi)
    local pos_offset = Text.offset(line.data, pos)

[178.242]

[178.391]

    local lo_offset = Text.offset(line, lo)
    local hi_offset = Text.offset(line, hi)
    local pos_offset = Text.offset(line, pos)

Replacement in select.lua at line 63 [129.43980]

B:BD[178.454] → [178.454:514]

      local before = line.data:sub(pos_offset, lo_offset-1)

[178.454]

[178.514]

      local before = line:sub(pos_offset, lo_offset-1)

Replacement in select.lua at line 68 [129.43980]

B:BD[178.706] → [178.706:758]

    local s = line.data:sub(lo_offset, hi_offset-1)

[178.706]

[178.758]

    local s = line:sub(lo_offset, hi_offset-1)

Replacement in select.lua at line 95 [129.43980]
∅:D[179.1531] → [129.46343:46375]
∅:D[31.79610] → [129.46343:46375]
B:BD[129.46343] → [129.46343:46375]
B:BD[129.46375] → [180.91:142]
B:BD[180.142] → [181.212:283]
∅:D[182.229] → [129.46471:46481]
∅:D[181.283] → [129.46471:46481]
∅:D[151.4292] → [129.46471:46481]
∅:D[165.6090] → [129.46471:46481]
B:BD[129.46471] → [129.46471:46481]
```
    if line.mode == 'text' then
      if Text.in_line(State, line_index, x,y) then
        return line_index, Text.to_pos_on_line(State, line_index, x,y)
      end
```
[179.1531]
[129.46481]
```
    if Text.in_line(State, line_index, x,y) then
      return line_index, Text.to_pos_on_line(State, line_index, x,y)
```

Replacement in select.lua at line 139 [129.43980]

∅:D[145.608] → [179.2656:2782]

B:BD[179.2656] → [179.2656:2782]

  local min_offset = Text.offset(State.lines[minl].data, minp)
  local max_offset = Text.offset(State.lines[maxl].data, maxp)

[145.608]

[129.47487]

  local min_offset = Text.offset(State.lines[minl], minp)
  local max_offset = Text.offset(State.lines[maxl], maxp)

Replacement in select.lua at line 143 [129.43980]

B:BD[129.47540] → [179.2783:2896]

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

[129.47540]

[129.47635]

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

Replacement in select.lua at line 147 [129.43980]
B:BD[129.47674] → [179.2897:2950]
```
  local rhs = State.lines[maxl].data:sub(max_offset)
```
[129.47674]
[129.47721]
```
  local rhs = State.lines[maxl]:sub(max_offset)
```

Replacement in select.lua at line 152 [129.43980]

B:BD[129.47780] → [179.2985:3061]

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

[129.47780]

[129.47844]

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

Replacement in select.lua at line 168 [129.43980]

B:BD[129.48224] → [179.3318:3444]

  local min_offset = Text.offset(State.lines[minl].data, minp)
  local max_offset = Text.offset(State.lines[maxl].data, maxp)

[129.48224]

[129.48338]

  local min_offset = Text.offset(State.lines[minl], minp)
  local max_offset = Text.offset(State.lines[maxl], maxp)

Replacement in select.lua at line 171 [129.43980]

B:BD[129.48361] → [179.3445:3509]

    return State.lines[minl].data:sub(min_offset, max_offset-1)

[129.48361]

[129.48419]

    return State.lines[minl]:sub(min_offset, max_offset-1)

Replacement in select.lua at line 174 [129.43980]

B:BD[129.48447] → [179.3510:3568]

  local result = {State.lines[minl].data:sub(min_offset)}

[129.48447]

[129.48503]

  local result = {State.lines[minl]:sub(min_offset)}

Replacement in select.lua at line 176 [129.43980]
B:BD[129.48528] → [179.3569:3659]
∅:D[183.100] → [129.48607:48615]
∅:D[179.3659] → [129.48607:48615]
∅:D[31.81719] → [129.48607:48615]
B:BD[129.48607] → [129.48607:48615]
```
    if State.lines[i].mode == 'text' then
      table.insert(result, State.lines[i].data)
    end
```
[129.48528]
[129.48615]
```
    table.insert(result, State.lines[i])
```

Replacement in select.lua at line 178 [129.43980]

B:BD[129.48621] → [179.3660:3728]

  table.insert(result, State.lines[maxl].data:sub(1, max_offset-1))

[129.48621]

[183.163]

  table.insert(result, State.lines[maxl]:sub(1, max_offset-1))

Replacement in search.lua at line 24 [129.48846]

B:BD[184.758] → [22.6:101]

  local pos = find(State.lines[State.cursor1.line].data, State.search_term, State.cursor1.pos)

[184.758]

[22.101]

  local pos = find(State.lines[State.cursor1.line], State.search_term, State.cursor1.pos)

Replacement in search.lua at line 31 [129.48846]

B:BD[185.211] → [22.144:201]

      pos = find(State.lines[i].data, State.search_term)

[185.211]

[22.201]

      pos = find(State.lines[i], State.search_term)

Replacement in search.lua at line 42 [129.48846]

B:BD[185.368] → [22.297:354]

      pos = find(State.lines[i].data, State.search_term)

[185.368]

[129.50189]

      pos = find(State.lines[i], State.search_term)

Replacement in search.lua at line 52 [129.48846]

B:BD[184.833] → [22.355:427]

    pos = find(State.lines[State.cursor1.line].data, State.search_term)

[184.833]

[22.427]

    pos = find(State.lines[State.cursor1.line], State.search_term)

Replacement in search.lua at line 72 [129.48846]

∅:D[23.800] → [186.751:849]

B:BD[129.50784] → [186.751:849]

  local pos = rfind(State.lines[State.cursor1.line].data, State.search_term, State.cursor1.pos-1)

[23.800]

[129.50856]

  local pos = rfind(State.lines[State.cursor1.line], State.search_term, State.cursor1.pos-1)

Replacement in search.lua at line 79 [129.48846]

B:BD[185.1238] → [185.1238:1296]

      pos = rfind(State.lines[i].data, State.search_term)

[185.1238]

[129.50998]

      pos = rfind(State.lines[i], State.search_term)

Replacement in search.lua at line 90 [129.48846]

B:BD[185.1411] → [185.1411:1469]

      pos = rfind(State.lines[i].data, State.search_term)

[185.1411]

[129.51229]

      pos = rfind(State.lines[i], State.search_term)

Replacement in search.lua at line 100 [129.48846]

B:BD[23.910] → [23.910:983]

    pos = rfind(State.lines[State.cursor1.line].data, State.search_term)

[23.910]

[23.983]

    pos = rfind(State.lines[State.cursor1.line], State.search_term)

Replacement in main_tests.lua at line 41 [187.7]

B:BD[31.84890] → [31.84890:85118]

  check_eq(Editor_state.lines[1].data, 'abc', 'F - test_drop_file/lines:1')
  check_eq(Editor_state.lines[2].data, 'def', 'F - test_drop_file/lines:2')
  check_eq(Editor_state.lines[3].data, 'ghi', 'F - test_drop_file/lines:3')

[31.84890]

[188.7]

  check_eq(Editor_state.lines[1], 'abc', 'F - test_drop_file/lines:1')
  check_eq(Editor_state.lines[2], 'def', 'F - test_drop_file/lines:2')
  check_eq(Editor_state.lines[3], 'ghi', 'F - test_drop_file/lines:3')

Insertion in main.lua at line 2 [190.2]
[124.30]
[189.3]
```
json = require 'json'
```
Deletion in main.lua at line 47 [190.2]
B:BD[31.85498] → [191.8:44]
```
    edit.fixup_cursor(Editor_state)
```

Deletion in main.lua at line 50 [190.2]

B:BD[40.7698] → [24.8:178]

    if Editor_state.cursor1.line > #Editor_state.lines or Editor_state.lines[Editor_state.cursor1.line].mode ~= 'text' then
      edit.fixup_cursor(Editor_state)
    end

Deletion in main.lua at line 127 [190.2]
B:BD[192.16] → [24.179:213]
```
  edit.fixup_cursor(Editor_state)
```

Replacement in file.lua at line 15 [54.15083]

B:BD[54.15620] → [54.15620:15864]

      if line == '```lines' then  -- inflexible with whitespace since these files are always autogenerated
        table.insert(result, load_drawing(infile_next_line))
      else
        table.insert(result, {mode='text', data=line})
      end

[54.15620]

[54.15864]

      table.insert(result, line)

Replacement in file.lua at line 19 [54.15083]
B:BD[54.15901] → [54.15901:15950]
```
    table.insert(result, {mode='text', data=''})
```
[54.15901]
[54.15950]
```
    table.insert(result, '')
```
Replacement in file.lua at line 30 [54.15083]
∅:D[15.419] → [54.16090:16169]
B:BD[54.16090] → [54.16090:16169]
B:BD[54.16169] → [6.14:51]
∅:D[6.51] → [54.16206:16214]
B:BD[54.16206] → [54.16206:16214]
```
    if line.mode == 'drawing' then
      store_drawing(outfile, line)
    else
      outfile:write(line.data, '\n')
    end
```
[15.419]
[54.16214]
```
    outfile:write(line, '\n')
```

Deletion in file.lua at line 35 [54.15083]

B:BD[54.16243] → [54.16243:16524]

B:BD[54.16524] → [71.1072:1235]

∅:D[71.1235] → [54.16586:16664]

B:BD[54.16586] → [54.16586:16664]

B:BD[54.16664] → [71.1236:1306]

∅:D[71.1306] → [54.16664:16742]

B:BD[54.16664] → [54.16664:16742]

B:BD[54.16742] → [71.1307:1350]

∅:D[71.1350] → [193.139:234]

B:BD[54.16742] → [193.139:234]

∅:D[193.234] → [54.16782:16825]

B:BD[54.16782] → [54.16782:16825]

B:BD[54.16825] → [71.1351:1379]

∅:D[71.1379] → [54.16825:16899]

B:BD[54.16825] → [54.16825:16899]

B:BD[54.16899] → [71.1380:1434]

∅:D[71.1434] → [54.16899:16971]

B:BD[54.16899] → [54.16899:16971]

B:BD[54.16971] → [71.1435:1472]

∅:D[71.1472] → [54.16971:17060]

B:BD[54.16971] → [54.16971:17060]

B:BD[54.17060] → [194.10:57]

B:BD[194.57] → [195.10:66]

∅:D[194.57] → [193.235:288]

∅:D[195.66] → [193.235:288]

∅:D[71.1519] → [193.235:288]

B:BD[54.17060] → [193.235:288]

∅:D[193.288] → [54.17060:17287]

B:BD[54.17060] → [54.17060:17287]

B:BD[54.17287] → [6.52:98]

∅:D[6.98] → [54.17333:17507]

B:BD[54.17333] → [54.17333:17507]

B:BD[54.17507] → [6.99:131]

∅:D[6.131] → [193.289:384]

B:BD[54.17539] → [193.289:384]

∅:D[193.384] → [54.17579:17771]

B:BD[54.17579] → [54.17579:17771]

B:BD[54.17771] → [6.132:164]

∅:D[6.164] → [54.17803:17842]

B:BD[54.17803] → [54.17803:17842]

B:BD[54.17842] → [6.165:281]

∅:D[6.281] → [54.17958:17994]

B:BD[54.17958] → [54.17958:17994]

B:BD[54.17994] → [6.282:456]

∅:D[6.456] → [195.67:123]

B:BD[54.18168] → [195.67:123]

∅:D[195.123] → [193.385:438]

B:BD[54.18168] → [193.385:438]

∅:D[193.438] → [54.18168:18207]

B:BD[54.18168] → [54.18168:18207]

B:BD[54.18207] → [143.1376:1381]

json = require 'json'
function load_drawing(infile_next_line)
  local drawing = {mode='drawing', h=256/2, points={}, shapes={}, pending={}}
  while true do
    local line = infile_next_line()
    assert(line)
    if line == '```' then break end
    local shape = json.decode(line)
    if shape.mode == 'freehand' then
      -- no changes needed
    elseif shape.mode == 'line' or shape.mode == 'manhattan' then
      local name = shape.p1.name
      shape.p1 = Drawing.insert_point(drawing.points, shape.p1.x, shape.p1.y)
      drawing.points[shape.p1].name = name
      name = shape.p2.name
      shape.p2 = Drawing.insert_point(drawing.points, shape.p2.x, shape.p2.y)
      drawing.points[shape.p2].name = name
    elseif shape.mode == 'polygon' or shape.mode == 'rectangle' or shape.mode == 'square' then
      for i,p in ipairs(shape.vertices) do
        local name = p.name
        shape.vertices[i] = Drawing.insert_point(drawing.points, p.x,p.y)
        drawing.points[shape.vertices[i]].name = name
      end
    elseif shape.mode == 'circle' or shape.mode == 'arc' then
      local name = shape.center.name
      shape.center = Drawing.insert_point(drawing.points, shape.center.x,shape.center.y)
      drawing.points[shape.center].name = name
    elseif shape.mode == 'deleted' then
      -- ignore
    else
      print(shape.mode)
      assert(false)
    end
    table.insert(drawing.shapes, shape)
  end
  return drawing
end
function store_drawing(outfile, drawing)
  outfile:write('```lines\n')
  for _,shape in ipairs(drawing.shapes) do
    if shape.mode == 'freehand' then
      outfile:write(json.encode(shape), '\n')
    elseif shape.mode == 'line' or shape.mode == 'manhattan' then
      local line = json.encode({mode=shape.mode, p1=drawing.points[shape.p1], p2=drawing.points[shape.p2]})
      outfile:write(line, '\n')
    elseif shape.mode == 'polygon' or shape.mode == 'rectangle' or shape.mode == 'square' then
      local obj = {mode=shape.mode, vertices={}}
      for _,p in ipairs(shape.vertices) do
        table.insert(obj.vertices, drawing.points[p])
      end
      local line = json.encode(obj)
      outfile:write(line, '\n')
    elseif shape.mode == 'circle' then
      outfile:write(json.encode({mode=shape.mode, center=drawing.points[shape.center], radius=shape.radius}), '\n')
    elseif shape.mode == 'arc' then
      outfile:write(json.encode({mode=shape.mode, center=drawing.points[shape.center], radius=shape.radius, start_angle=shape.start_angle, end_angle=shape.end_angle}), '\n')
    elseif shape.mode == 'deleted' then
      -- ignore
    else
      print(shape.mode)
      assert(false)
    end
  end
  outfile:write('```\n')
end

Replacement in file.lua at line 43 [54.15083]

B:BD[143.1566] → [196.2583:2603]

∅:D[196.2603] → [143.1566:1671]

B:BD[143.1566] → [143.1566:1671]

B:BD[143.1671] → [196.2604:2765]

∅:D[196.2765] → [143.1740:1749]

B:BD[143.1740] → [143.1740:1749]

B:BD[143.1749] → [196.2766:2800]

∅:D[196.2800] → [143.1749:1810]

B:BD[143.1749] → [143.1749:1810]

--?     print(line)
    if line == '```lines' then  -- inflexible with whitespace since these files are always autogenerated
--?       print('inserting drawing')
      i, drawing = load_drawing_from_array(next_line, a, i)
--?       print('i now', i)
      table.insert(result, drawing)
    else
--?       print('inserting text')
      table.insert(result, {mode='text', data=line})
    end

[143.1566]

[143.1810]

    table.insert(result, line)

Replacement in file.lua at line 46 [54.15083]
B:BD[143.1839] → [143.1839:1888]
```
    table.insert(result, {mode='text', data=''})
```
[143.1839]
[143.1888]
```
    table.insert(result, '')
```

Deletion in file.lua at line 49 [54.15083]

B:BD[143.1910] → [143.1910:2106]

B:BD[143.2106] → [196.2801:2818]

∅:D[196.2818] → [143.2106:3102]

B:BD[143.2106] → [143.2106:3102]

B:BD[143.3102] → [194.58:105]

B:BD[194.105] → [195.124:180]

∅:D[194.105] → [143.3148:3255]

∅:D[195.180] → [143.3148:3255]

B:BD[143.3148] → [143.3148:3255]

B:BD[143.3255] → [196.2819:2839]

end
function load_drawing_from_array(iter, a, i)
  local drawing = {mode='drawing', h=256/2, points={}, shapes={}, pending={}}
  local line
  while true do
    i, line = iter(a, i)
    assert(i)
--?     print(i)
    if line == '```' then break end
    local shape = json.decode(line)
    if shape.mode == 'freehand' then
      -- no changes needed
    elseif shape.mode == 'line' or shape.mode == 'manhattan' then
      local name = shape.p1.name
      shape.p1 = Drawing.insert_point(drawing.points, shape.p1.x, shape.p1.y)
      drawing.points[shape.p1].name = name
      name = shape.p2.name
      shape.p2 = Drawing.insert_point(drawing.points, shape.p2.x, shape.p2.y)
      drawing.points[shape.p2].name = name
    elseif shape.mode == 'polygon' or shape.mode == 'rectangle' or shape.mode == 'square' then
      for i,p in ipairs(shape.vertices) do
        local name = p.name
        shape.vertices[i] = Drawing.insert_point(drawing.points, p.x,p.y)
        drawing.points[shape.vertices[i]].name = name
      end
    elseif shape.mode == 'circle' or shape.mode == 'arc' then
      local name = shape.center.name
      shape.center = Drawing.insert_point(drawing.points, shape.center.x,shape.center.y)
      drawing.points[shape.center].name = name
    elseif shape.mode == 'deleted' then
      -- ignore
    else
      print(shape.mode)
      assert(false)
    end
    table.insert(drawing.shapes, shape)
  end
  return i, drawing

Deletion in edit.lua at line 4 [197.413]

B:BD[66.519] → [66.519:712]

Stroke_color = {r=0, g=0, b=0}
Current_stroke_color = {r=0.7, g=0.7, b=0.7}  -- in process of being drawn
Current_name_background_color = {r=1, g=0, b=0, a=0.1}  -- name currently being edited

Deletion in edit.lua at line 6 [197.413]

B:BD[66.839] → [66.839:997]

Icon_color = {r=0.7, g=0.7, b=0.7}  -- color of current mode icon in drawings
Help_color = {r=0, g=0.5, b=0}
Help_background_color = {r=0, g=0.5, b=0, a=0.1}

Deletion in edit.lua at line 11 [197.413]

B:BD[33.401] → [33.401:524]

∅:D[33.524] → [69.15:103]

B:BD[34.22248] → [69.15:103]

∅:D[69.103] → [34.22248:22249]

B:BD[34.22248] → [34.22248:22249]

Drawing_padding_top = 10
Drawing_padding_bottom = 10
Drawing_padding_height = Drawing_padding_top + Drawing_padding_bottom
Same_point_distance = 4  -- pixel distance at which two points are considered the same

Deletion in edit.lua at line 15 [197.413]
B:BD[197.484] → [197.484:548]
```
require 'drawing'
require 'geom'
require 'help'
require 'icons'
```

Replacement in edit.lua at line 21 [197.413]

B:BD[31.94338] → [31.94338:94459]

B:BD[31.94918] → [31.94918:95767]

B:BD[31.95767] → [40.7706:7763]

    -- a line is either text or a drawing
    -- a text is a table with:
    --    mode = 'text',
    --    string data,
    -- a drawing is a table with:
    --    mode = 'drawing'
    --    a (y) coord in pixels (updated while painting screen),
    --    a (h)eight,
    --    an array of points, and
    --    an array of shapes
    -- a shape is a table containing:
    --    a mode
    --    an array points for mode 'freehand' (raw x,y coords; freehand drawings don't pollute the points array of a drawing)
    --    an array vertices for mode 'polygon', 'rectangle', 'square'
    --    p1, p2 for mode 'line'
    --    center, radius for mode 'circle'
    --    center, radius, start_angle, end_angle for mode 'arc'
    -- Unless otherwise specified, coord fields are normalized; a drawing is always 256 units wide
    -- The field names are carefully chosen so that switching modes in midstream
    -- remembers previously entered points where that makes sense.
    lines = {{mode='text', data=''}},  -- array of lines

[31.94338]

[197.1993]

    lines = {''},  -- array of strings

Deletion in edit.lua at line 58 [197.413]

B:BD[197.3184] → [31.97073:97217]

∅:D[31.97217] → [197.3320:3321]

B:BD[197.3320] → [197.3320:3321]

    current_drawing_mode = 'line',
    previous_drawing_mode = nil,  -- extra state for some ephemeral modes like moving/deleting/naming points

Deletion in edit.lua at line 82 [197.413]

B:BD[197.3868] → [191.89:123]

B:BD[191.123] → [24.221:333]

∅:D[24.333] → [191.347:366]

B:BD[191.347] → [191.347:366]

function edit.fixup_cursor(State)
  for i,line in ipairs(State.lines) do
    if line.mode == 'text' then
      State.cursor1.line = i
      break
    end
  end
end

Replacement in edit.lua at line 97 [197.413]

B:BD[30.3138] → [198.15:91]

B:BD[198.91] → [199.273:298]

∅:D[199.298] → [198.92:143]

B:BD[197.4442] → [198.92:143]

B:BD[198.143] → [199.299:340]

∅:D[199.340] → [198.189:609]

B:BD[198.189] → [198.189:609]

B:BD[198.609] → [147.1896:1966]

∅:D[147.1966] → [198.609:972]

∅:D[40.8494] → [198.609:972]

B:BD[198.609] → [198.609:972]

∅:D[198.972] → [197.5229:5239]

B:BD[197.5229] → [197.5229:5239]

B:BD[197.5239] → [199.341:419]

∅:D[199.419] → [30.3585:3617]

∅:D[198.1038] → [30.3585:3617]

B:BD[30.3585] → [30.3585:3617]

B:BD[30.3617] → [198.1039:1066]

∅:D[198.1066] → [197.5308:5347]

∅:D[30.3617] → [197.5308:5347]

∅:D[31.99122] → [197.5308:5347]

B:BD[197.5308] → [197.5308:5347]

B:BD[197.5347] → [33.525:557]

B:BD[33.557] → [13.15:56]

∅:D[13.56] → [33.558:633]

B:BD[56.47] → [33.558:633]

∅:D[33.633] → [197.5483:5492]

∅:D[67.684] → [197.5483:5492]

∅:D[30.3725] → [197.5483:5492]

∅:D[31.99244] → [197.5483:5492]

B:BD[197.5483] → [197.5483:5492]

B:BD[197.5492] → [198.1067:1110]

    if line.mode == 'text' then
--?       print('text.draw', y, line_index)
      local startpos = 1
      if line_index == State.screen_top1.line then
        startpos = State.screen_top1.pos
      end
      if line.data == '' then
        -- button to insert new drawing
        button('draw', {x=4,y=y+4, w=12,h=12, color={1,1,0},
          icon = icon.insert_drawing,
          onpress1 = function()
                       Drawing.before = snapshot(State, line_index-1, line_index)
                       table.insert(State.lines, line_index, {mode='drawing', y=y, h=256/2, points={}, shapes={}, pending={}})
                       table.insert(State.line_cache, line_index, {})
                       if State.cursor1.line >= line_index then
                         State.cursor1.line = State.cursor1.line+1
                       end
                       schedule_save(State)
                       record_undo_event(State, {before=Drawing.before, after=snapshot(State, line_index-1, line_index+1)})
                     end,
        })
      end
      y, State.screen_bottom1.pos = Text.draw(State, line_index, y, startpos)
      y = y + State.line_height
--?       print('=> y', y)
    elseif line.mode == 'drawing' then
      y = y+Drawing_padding_top
      Drawing.draw(State, line_index, y)
      y = y + Drawing.pixels(line.h, State.width) + Drawing_padding_bottom
    else
      print(line.mode)
      assert(false)

[30.3138]

[197.5845]

--?     print('text.draw', y, line_index)
    local startpos = 1
    if line_index == State.screen_top1.line then
      startpos = State.screen_top1.pos

Insertion in edit.lua at line 102 [197.413]

[197.5853]

    y, State.screen_bottom1.pos = Text.draw(State, line_index, y, startpos)
    y = y + State.line_height
--?     print('=> y', y)

Replacement in edit.lua at line 109 [197.413]

B:BD[197.5923] → [30.4061:4191]

--?   print('screen bottom: '..tostring(State.screen_bottom1.pos)..' in '..tostring(State.lines[State.screen_bottom1.line].data))

[197.5923]

[30.4191]

--?   print('screen bottom: '..tostring(State.screen_bottom1.pos)..' in '..tostring(State.lines[State.screen_bottom1.line]))

Deletion in edit.lua at line 116 [197.413]
B:BD[30.4252] → [92.15:43]
```
  Drawing.update(State, dt)
```

Replacement in edit.lua at line 141 [197.413]

∅:D[30.4696] → [197.7059:7091]

∅:D[31.100424] → [197.7059:7091]

B:BD[197.7059] → [197.7059:7091]

B:BD[197.7091] → [180.153:204]

∅:D[200.60] → [197.7173:7631]

∅:D[180.204] → [197.7173:7631]

∅:D[30.4791] → [197.7173:7631]

∅:D[165.6356] → [197.7173:7631]

∅:D[34.22676] → [197.7173:7631]

∅:D[31.100533] → [197.7173:7631]

B:BD[197.7173] → [197.7173:7631]

B:BD[197.7631] → [10.15:82]

∅:D[10.82] → [30.4792:4961]

B:BD[197.7697] → [30.4792:4961]

∅:D[30.4961] → [197.7830:7859]

∅:D[31.100745] → [197.7830:7859]

B:BD[197.7830] → [197.7830:7859]

B:BD[197.7859] → [181.294:356]

∅:D[200.117] → [197.7952:7962]

∅:D[181.356] → [197.7952:7962]

∅:D[30.5067] → [197.7952:7962]

∅:D[165.6469] → [197.7952:7962]

∅:D[34.22758] → [197.7952:7962]

∅:D[31.100865] → [197.7952:7962]

B:BD[197.7952] → [197.7952:7962]

B:BD[197.7962] → [30.5068:5144]

∅:D[30.5144] → [197.8026:8089]

∅:D[31.100956] → [197.8026:8089]

B:BD[197.8026] → [197.8026:8089]

B:BD[197.8089] → [13.57:192]

∅:D[13.192] → [30.5145:5243]

∅:D[67.754] → [30.5145:5243]

B:BD[197.8134] → [30.5145:5243]

B:BD[30.5243] → [127.2242:2295]

B:BD[127.2295] → [13.193:261]

∅:D[88.77] → [197.8321:8345]

∅:D[13.261] → [197.8321:8345]

B:BD[197.8321] → [197.8321:8345]

    if line.mode == 'text' then
      if Text.in_line(State, line_index, x,y) then
        -- 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()
        State.selection1 = {
            line=line_index,
            pos=Text.to_pos_on_line(State, line_index, x, y),
        }
--?         print('selection', State.selection1.line, State.selection1.pos)
        break
      end
    elseif line.mode == 'drawing' then
      local line_cache = State.line_cache[line_index]
      if Drawing.in_drawing(line, line_cache, x, y, State.left,State.right) then
        State.lines.current_drawing_index = line_index
        State.lines.current_drawing = line
        Drawing.before = snapshot(State, line_index)
        Drawing.mouse_pressed(State, line_index, x,y, mouse_button)
        break
      end

[30.4696]

[197.8345]

    if Text.in_line(State, line_index, x,y) then
      -- 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()
      State.selection1 = {
          line=line_index,
          pos=Text.to_pos_on_line(State, line_index, x, y),
      }
--?       print('selection', State.selection1.line, State.selection1.pos)
      break

Replacement in edit.lua at line 167 [197.413]

B:BD[197.8468] → [30.5339:5377]

B:BD[30.5377] → [98.15:68]

B:BD[98.68] → [201.420:445]

∅:D[201.445] → [197.8641:8668]

B:BD[197.8641] → [197.8641:8668]

B:BD[197.8668] → [127.2296:2410]

∅:D[127.2410] → [197.8762:8804]

∅:D[30.5478] → [197.8762:8804]

∅:D[31.101270] → [197.8762:8804]

B:BD[197.8762] → [197.8762:8804]

B:BD[197.8804] → [30.5479:5529]

∅:D[30.5529] → [197.8848:8882]

∅:D[31.101328] → [197.8848:8882]

B:BD[197.8848] → [197.8848:8882]

B:BD[197.8882] → [180.205:258]

∅:D[200.165] → [197.8966:9005]

∅:D[180.258] → [197.8966:9005]

∅:D[30.5626] → [197.8966:9005]

∅:D[165.6573] → [197.8966:9005]

∅:D[34.22831] → [197.8966:9005]

∅:D[31.101439] → [197.8966:9005]

B:BD[197.8966] → [197.8966:9005]

B:BD[197.9005] → [30.5627:5655]

∅:D[30.5655] → [197.9027:9058]

∅:D[31.101475] → [197.9027:9058]

B:BD[197.9027] → [197.9027:9058]

B:BD[197.9058] → [181.357:421]

∅:D[200.224] → [197.9153:9165]

∅:D[181.421] → [197.9153:9165]

∅:D[30.5763] → [197.9153:9165]

∅:D[165.6688] → [197.9153:9165]

∅:D[34.22915] → [197.9153:9165]

∅:D[31.101597] → [197.9153:9165]

B:BD[197.9153] → [197.9153:9165]

B:BD[197.9165] → [30.5764:5978]

∅:D[30.5978] → [197.9343:9360]

∅:D[31.101854] → [197.9343:9360]

B:BD[197.9343] → [197.9343:9360]

B:BD[197.9360] → [30.5979:6033]

∅:D[30.6033] → [197.9402:9432]

∅:D[31.101923] → [197.9402:9432]

B:BD[197.9402] → [197.9402:9432]

B:BD[197.9432] → [30.6034:6202]

∅:D[30.6202] → [197.9564:9594]

∅:D[31.102134] → [197.9564:9594]

B:BD[197.9564] → [197.9564:9594]

  if State.lines.current_drawing then
    Drawing.mouse_released(State, x,y, mouse_button)
    schedule_save(State)
    if Drawing.before then
      record_undo_event(State, {before=Drawing.before, after=snapshot(State, State.lines.current_drawing_index)})
      Drawing.before = nil
    end
  else
    for line_index,line in ipairs(State.lines) do
      if line.mode == 'text' then
        if Text.in_line(State, line_index, x,y) then
--?           print('reset selection')
          State.cursor1 = {
              line=line_index,
              pos=Text.to_pos_on_line(State, line_index, x, y),
          }
--?           print('cursor', State.cursor1.line, State.cursor1.pos)
          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

[197.8468]

[197.9594]

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

Insertion in edit.lua at line 182 [197.413]

[197.9616]

      State.old_cursor1, State.old_selection1, State.mousepress_shift = nil
      if eq(State.cursor1, State.selection1) then
        State.selection1 = {}
      end
      break

Deletion in edit.lua at line 188 [197.413]

B:BD[197.9624] → [30.6203:6276]

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

Insertion in edit.lua at line 189 [197.413]

[197.9691]

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

Deletion in edit.lua at line 198 [197.413]

∅:D[185.2117] → [30.6496:6547]

B:BD[197.9975] → [30.6496:6547]

B:BD[30.6547] → [127.2411:2481]

∅:D[127.2481] → [30.6610:6658]

B:BD[30.6610] → [30.6610:6658]

∅:D[30.6658] → [197.10119:10201]

∅:D[31.102626] → [197.10119:10201]

B:BD[197.10119] → [197.10119:10201]

B:BD[197.10201] → [127.2482:2586]

  elseif State.current_drawing_mode == 'name' then
    local before = snapshot(State, State.lines.current_drawing_index)
    local drawing = State.lines.current_drawing
    local p = drawing.points[drawing.pending.target_point]
    p.name = p.name..t
    record_undo_event(State, {before=before, after=snapshot(State, State.lines.current_drawing_index)})

Deletion in edit.lua at line 206 [197.413]
B:BD[30.6831] → [30.6831:6873]
```
      not State.lines.current_drawing and
```

Replacement in edit.lua at line 313 [197.413]

∅:D[127.2812] → [197.14470:14561]

∅:D[30.9002] → [197.14470:14561]

∅:D[31.105277] → [197.14470:14561]

B:BD[197.14470] → [197.14470:14561]

B:BD[197.14561] → [16.1250:1292]

∅:D[16.1292] → [107.15:81]

B:BD[197.14592] → [107.15:81]

∅:D[107.81] → [197.14653:14679]

B:BD[197.14653] → [197.14653:14679]

B:BD[197.14679] → [127.2813:2865]

∅:D[127.2865] → [105.15:60]

B:BD[197.14724] → [105.15:60]

B:BD[105.60] → [127.2866:2952]

∅:D[127.2952] → [201.578:605]

B:BD[197.14834] → [201.578:605]

∅:D[201.605] → [197.14856:14922]

B:BD[197.14856] → [197.14856:14922]

B:BD[197.14922] → [30.9003:9044]

∅:D[30.9044] → [197.14957:15043]

∅:D[31.105326] → [197.14957:15043]

B:BD[197.14957] → [197.14957:15043]

B:BD[197.15043] → [30.9045:9096]

∅:D[30.9096] → [197.15088:15118]

∅:D[31.105385] → [197.15088:15118]

B:BD[197.15088] → [197.15088:15118]

B:BD[197.15118] → [30.9097:9200]

∅:D[30.9200] → [197.15203:15212]

∅:D[31.105510] → [197.15203:15212]

B:BD[197.15203] → [197.15203:15212]

B:BD[197.15212] → [127.2953:3025]

∅:D[127.3025] → [30.9266:9316]

B:BD[30.9266] → [30.9266:9316]

∅:D[30.9316] → [197.15315:15429]

∅:D[31.105640] → [197.15315:15429]

B:BD[197.15315] → [197.15315:15429]

B:BD[197.15429] → [127.3026:3134]

∅:D[127.3134] → [197.15517:15745]

∅:D[30.9411] → [197.15517:15745]

∅:D[31.105742] → [197.15517:15745]

B:BD[197.15517] → [197.15517:15745]

B:BD[197.15745] → [127.3135:3243]

∅:D[127.3243] → [197.15833:15851]

∅:D[30.9506] → [197.15833:15851]

∅:D[31.105844] → [197.15833:15851]

B:BD[197.15833] → [197.15833:15851]

B:BD[197.15851] → [201.606:631]

  -- dispatch to drawing or text
  elseif App.mouse_down(1) or chord:sub(1,2) == 'C-' then
    -- DON'T reset line_cache.starty here
    local drawing_index, drawing = Drawing.current_drawing(State)
    if drawing_index then
      local before = snapshot(State, drawing_index)
      Drawing.keychord_pressed(State, chord)
      record_undo_event(State, {before=before, after=snapshot(State, drawing_index)})
      schedule_save(State)
    end
  elseif chord == 'escape' and not App.mouse_down(1) then
    for _,line in ipairs(State.lines) do
      if line.mode == 'drawing' then
        line.show_help = false
      end
    end
  elseif State.current_drawing_mode == 'name' then
    if chord == 'return' then
      State.current_drawing_mode = State.previous_drawing_mode
      State.previous_drawing_mode = nil
    else
      local before = snapshot(State, State.lines.current_drawing_index)
      local drawing = State.lines.current_drawing
      local p = drawing.points[drawing.pending.target_point]
      if chord == 'escape' then
        p.name = nil
        record_undo_event(State, {before=before, after=snapshot(State, State.lines.current_drawing_index)})
      elseif chord == 'backspace' then
        local len = utf8.len(p.name)
        local byte_offset = Text.offset(p.name, len-1)
        if len == 1 then byte_offset = 0 end
        p.name = string.sub(p.name, 1, byte_offset)
        record_undo_event(State, {before=before, after=snapshot(State, State.lines.current_drawing_index)})
      end
    end
    schedule_save(State)

[127.2812]

[197.15871]

  -- dispatch to text

Replacement in README.md at line 1 [202.6]

B:BD[202.6] → [203.14:38]

# Plain text with lines

[202.6]

[204.18]

# An editor for plain text.
Not very useful by itself, but it's a fork of [lines.love](http://akkartik.name/lines.html)
that you can take in other directions besides line drawings, while easily
sharing patches between forks.

Deletion in README.md at line 7 [202.6]

B:BD[204.19] → [204.19:96]

An editor for plain text where you can also seamlessly insert line drawings.

Deletion in README.md at line 10 [202.6]
B:BD[203.39] → [203.39:71]
B:BD[203.71] → [205.18:19]
```
http://akkartik.name/lines.html
```
Replacement in README.md at line 17 [202.6]
B:BD[25.242] → [25.242:273]
```
$ zip -r /tmp/lines.love *.lua
```
[25.242]
[25.273]
```
$ zip -r /tmp/text.love *.lua
```

Replacement in README.md at line 20 [202.6]

B:BD[204.223] → [204.223:296]

By default, lines.love reads/writes the file `lines.txt` in your default

[204.223]

[204.296]

By default, it reads/writes the file `lines.txt` in your default

Replacement in README.md at line 23 [202.6]

B:BD[204.379] → [206.59:119]

To open a different file, drop it on the lines.love window.

[204.379]

[204.504]

To open a different file, drop it on the app window.

Replacement in README.md at line 39 [202.6]

B:BD[5.19] → [5.19:95]

lines.love has been exclusively tested so far with a US keyboard layout. If

[5.19]

[5.95]

Exclusively tested so far with a US keyboard layout. If

Replacement in README.md at line 50 [202.6]

B:BD[207.95] → [8.19:101]

  other ways. lines.love works well in all circumstances with files under
  50KB.

[207.95]

[208.276]

  other ways. Works well in all circumstances with files under 50KB.

Replacement in README.md at line 83 [202.6]

B:BD[204.1142] → [204.1142:1497]

B:BD[204.1497] → [26.20:62]

∅:D[26.62] → [204.1497:1528]

B:BD[204.1497] → [204.1497:1528]

Updates to lines.love can be downloaded from the following mirrors in addition
to the website above:
* https://github.com/akkartik/lines.love
* https://repo.or.cz/lines.love.git
* https://codeberg.org/akkartik/lines.love
* https://tildegit.org/akkartik/lines.love
* https://git.tilde.institute/akkartik/lines.love
* https://git.sr.ht/~akkartik/lines.love
* https://notabug.org/akkartik/lines.love
* https://pagure.io/lines.love

[204.1142]

[204.1528]

This repo is a fork of lines.love at [http://akkartik.name/lines.html](http://akkartik.name/lines.html).
Updates to it can be downloaded from the following mirrors:

Replacement in README.md at line 86 [202.6]

B:BD[204.1529] → [4.18:96]

∅:D[4.96] → [204.1603:1609]

B:BD[204.1603] → [204.1603:1609]

B:BD[204.1609] → [209.18:197]

B:BD[209.197] → [9.19:40]

Forks of lines.love are encouraged. If you show me your fork, I'll link to it
here.
* https://github.com/akkartik/lines-polygon-experiment -- an experiment that
  uses separate shortcuts for regular polygons. `ctrl+3` for triangles,
  `ctrl+4` for squares, etc.
## Associated tools

[204.1529]

[204.1609]

* https://codeberg.org/akkartik/text.love
* https://repo.or.cz/text.love.git
* https://tildegit.org/akkartik/text.love
* https://git.tilde.institute/akkartik/text.love
* https://git.sr.ht/~akkartik/text.love
* https://notabug.org/akkartik/text.love
* https://github.com/akkartik/text.love
* https://pagure.io/text.love

Replacement in README.md at line 95 [202.6]

B:BD[204.1610] → [9.41:145]

* https://codeberg.org/akkartik/lines2md exports lines.love files to Markdown
  and (non-editable) SVG.

[204.1610]

[9.145]

Further forks are encouraged. If you show me your fork, I'll link to it here.