Scenario: backspacing until a line takes up fewer screen lines, then
pressing `down`.
I've gone through and checked that fragments and screen_line_starting_pos
are now cleared together everywhere.
I'm giving up finding a more generalized solution. The issue is that we
need the correct selection state right up to the point where we modify
Lines, in order to capture precise undo state.
Hopefully there aren't any other keychords that should clear the
selection.
We just need to ensure textinput events never make use of selection
state.
All tests are passing, but I'm aware of a couple of issues. But now we
can keep all the special cases in one place.
Now all the cases that clear Selection1 do so in a very consistent way
at the end of each case. And cases that set Selection1 symmetrically do
so at the start of each case.
Bugfix: we want selections to persist even when we lift up the shift
key.
This requires hoisting some code inside every case inside the whole
keypress hierarchy, to ensure we never clear selections before
textinput events can handle them.
Current cross-cutting concerns we're explicitly scattering code for.
- autosave
- undo
- selection management
To reproduce:
click to position cursor at end of a line
hit enter
press any key
before:
newline got erased and key got added to previous line
now:
newline is preserved
The new test checks a generalization of this.
It might reduce wear and tear on disk, and losing 3 seconds of data
doesn't feel catastrophic (short of a C-z rampage).
Thanks to the love2d.org community for the suggestion:
https://love2d.org/forums/viewtopic.php?f=14&t=93173
Not sure where that idiom comes from or why strings work in some places
(auto-coercion?). I picked it up off some example apps. But
https://love2d.org/wiki/love.mouse.isDown says it should be an integer.
manifestation: clicking past end of a long, wrapping line containing
non-ASCII would cause the cursor to disappear rather than position past
end of screen line. Hitting enter would then throw an assertion with the
following stack trace:
Error: text.lua:381: bad argument #2 to 'sub' (number expected, got nil)
stack traceback:
[love "boot.lua"]:345: in function <[love "boot.lua"]:341>
[C]: in function 'sub'
text.lua:381: in function 'insert_return'
text.lua:179: in function 'keychord_pressed'
main.lua:495: in function 'keychord_pressed'
keychord.lua:10: in function <keychord.lua:5>
app.lua:34: in function <app.lua:25>
[C]: in function 'xpcall'
cause: the click caused a call to Text.to_pos_on_line whose result was
not on a UTF-8 character boundary.
fix: make to_pos_on_line utf8-aware.
We have a regression since we started reclaiming love Text fragments
more aggressively in commit 69c5d844cc. Pressing pageup no longer knows
about any line's screen lines. Not fixed yet.
All signs so far seem to be that CPU is cheap for this application, but
memory is expensive. It's easy to get sluggish if the GC comes on.
After some experiments using https://github.com/yaukeywang/LuaMemorySnapshotDump,
one source of memory leaks is rendered fragments (https://love2d.org/wiki/Text
objects). I need to render text in approximately word-sized fragments to
mostly break lines more intelligently at word boundaries.
I've attached the files I used for my experiments (suffixed with a '.')
There's definitely still a leak in fragments. The longer I edit, the
more memory goes to them.
I've tried to keep the time period of the blinking similar to my
terminal.
Honestly I'm no longer sure if any of my experiments are showing a
statistically significant result. Let's see how it feels over a period
of time.
I'm testing this by moving the cursor around with my eyes closed, then
starting a stopwatch as I open my eyes. This seems to help a bit. I'm
able to acquire the cursor in 2s. At least the 10s outliers I used to
have with the circle or thin line don't seem to be happening.
I'm being unprincipled at the moment between pos and x,y coordinates.
Whatever is more convenient. Perhaps a cleaner approach will come to me
over time.
I almost pushed this to production. That would have been catastrophic;
the very first keystroke anyone typed into the editor would have failed.
And in the process, this fixes the next bug on my TODO list! Paste on
first line wasn't working. Now it is.
When long wrapping lines go past the current page, I find myself
scrolling before I get to the bottom. So let's scroll less, usually from
the start of the bottom-most line, even if it wraps multiple screen
lines.
The challenge with this is to ensure that a long line that fills the
whole page by itself doesn't get you stuck. I take some care to make
sure <pagedown> always makes forward progress.
Mouse stuff is pretty strenuous. For the first time I have to be careful
not to recompute too often. And I ran into a race condition for the
first time where resetting line.y within App.draw meant mouse clicks
were extremely unlikely to see line.y set.
Incredibly inefficient, but I don't yet know how to efficiently encode
undo mutations that can span multiple lines.
There seems to be one bug related to creating new drawings; they're not
spawning events and undoing past drawing creation has some weird
artifacts. Redo seems to consistently work, though.
I've written a few tests for delete_selection, but the way different
operations initialize the selection seems fairly standard and not worth
testing so far.
I'm now extracting the concern of computing
line.screen_line_starting_pos out of Text.draw. Earlier
I had to make sure I ran through the whole line to compute
screen_line_starting_pos, but that had the side-effect of updating
Screen_bottom1.pos as well with lines that had never been rendered.
In this process I hit my first bug due to an accidental global. It
doesn't show up in the patch because I accidentally deleted a local
declaration. (I thought I didn't need screen_line_starting_pos anymore,
deleted everywhere, then brought it back everywhere from the bottom of
the function up, but forgot to put back the very first occurrence.)
The amount of yoyoing this caused between App.draw and Text.draw, I very
much have spaghetti on my hands.
Accidental globals are _terrible_ in a program with tests. Cross test
contamination X-(
I also really need to rethink how people debug my programs. My approach
of inserting and deleting print() takes a lot of commitment. I need my
old trace-based whitebox testing idea. However, in my past projects I
never did figure out a good framework for tweaking how verbose a trace
to emit.
Perhaps that's too many knobs. Perhaps we just need a way to run a
single test with the most verbose trace possible. Then it's just a
matter of having the trace tell a coherent story? But even if the trace
stays out of program output in that situation, it's still in the
programmer's face in the _code_. Ugh.
Current plan: ship program with maximum tests and zero commented-out
prints. If you want to debug, insert prints. This is better than
previous, text-mode, projects just by virtue of the stdout channel being
dedicated to debug stuff.
So far I've just changed how existing variables are organized, and put
some scaffolding in place for dealing with the new types. Next up:
rewriting the code for scrolling to something that feels more obviously
correct.
Still lots of signs it's all messed up, but I can't be sure until I
bring all the other keyboard shortcuts in sync.
I just need a better data structure that simplifies the logic. Perhaps
talk in terms of screen lines. In which case:
We'll need to convert lines to screen lines at some point.
We'll need to fix up screen lines when inserting and deleting
characters.
I'd wrapped currx in two conditionals, and not noticed that it gets
reclaimed within the other.
The hint is clearly more work than it's worth. Just take it out.
Kartik K. Agaram