Removing multicell chars cleared only their text and the is_multicell flag,
leaving their other multicell fields. Code that did not check is_multicell
then mistook the removed cells for parts of multicell chars, so chars were
placed after unrelated rows and rewrap copied unrelated lines below such a
cell as the lower rows of a multiline char, tearing chars. Now all the
multicell fields are cleared and rewrap checks is_multicell.
The marker that preserves a blank cursor line during a resize was assumed
to be at the start of the line, but rewrap can place it after the lower
rows of multiline chars from the lines above, so removing it changed the
char at the start of the line instead, tearing multiline chars there. Now
the marker is removed where it is, just before the cursor.
When moving the screen into the scrollback for ED 22, the number of lines
to move was computed from the visual lines, which are lines from the
scrollback when it is scrolled. So too many lines were moved, adding blank
lines to the scrollback, or too few, tearing multiline chars. Now the lines
of the screen are used.
When looking for space free of the lower rows of multiline chars, with the
cursor on the last line below the bottom margin, a linefeed does not move
the cursor, so move_cursor_past_multicell() looped forever. Now it makes
space at the end of the line in that case.
move_cursor_past_multicell() also removed only the multicell char under the
cursor, not other chars in the cells the char being drawn would occupy. So
a wide char, for example one widened by VS16 at the end of a line, could
overwrite the first cells of a multiline char, leaving fragments of it.
Inserting chars before such a fragment looped forever, as the end of the
fragment was computed from its width ignoring its scale, so the loop went
backwards. Now all multicell chars in those cells are removed, and the end
of a char is computed from its scale and width and is always after the
current cell.
Also a char widened at the end of the line that was moved to cells
overlapping its original cell had its second cell cleared.
Scrolling down (CSI T) could cut off the lower rows of a scale > 1 text
sizing character at the bottom of the screen. Adding a combining char to
it then wrote past the end of the line buffer in add_combining_char and
rewrapping on resize read past the end of the line buffer in
copy_multiline_extra_lines.
Multiline chars that are cut off at the edge of the screen or of the
history buffer, by scrolling or by inserting lines, are partially
scrolled off and are rendered as such, so they are kept. Code walking the rows of a multiline char now only visits
the adjacent rows that actually continue the char, rather than trusting
the y and scale of a cell, so it stays in bounds and does not modify
unrelated cells for partial or torn chars.
Chars that would be torn, i.e. left with rows from unrelated lines
adjacent to their remaining part, are removed. This happens when
scrolling with margins, when a partial char is moved away from the edge
of the screen by scrolling or deleting lines, when inserting lines pushes
the lower rows of a char straddling the bottom margin out of the scroll
region, and when a partial char
cut off at the bottom is no longer at the bottom after a resize. Rewrap
drops partial chars, as it already did for chars with missing top rows,
placing cursors that were on them where the char would have been.
The checks for torn chars are skipped unless a multiline char has been
drawn in the screen, and chars cut off at the bottom of the screen,
which can only be created by scrolling down or inserting lines, are
tracked so that
linefeeds do not need to scan for them.
A hard reset now clears the alternate screen as well, so that the flag
tracking whether multiline chars have been used can be reset.
Also fix the lower rows of multiline chars being lost on rewrap when the
lines after the char were continuations that fit on its first row.
screen_draw_overlay_line accessed self->linebuf->line->cpu_cells
without ever calling linebuf_init_line on the shared view. Render
paths that initialize a stack-local Line via render_line_for_virtual_y
left the view's cpu_cells as NULL (the value set by alloc_line via
PyType_GenericAlloc), and the multicell-trim loop then dereferenced
NULL + xstart * sizeof(CPUCell), producing a SIGSEGV at a small
address (e.g. 0x1e for xstart=2). The crash was reachable any time
an IME pre-edit overlay was rendered with the cursor not in column 0
on a screen whose linebuf->line had not been re-pointed by some
unrelated prior call.
Fix by initializing the view at the overlay row on entry. Add a
test_draw_overlay_line method on Screen so the behavior can be
exercised directly from a regression test.
Note this only fixes the test, there is still the actual issue of
the selection not being rendered for the top most line if that line is
partially scrolled offscreen
When the end point of the selection is within a multicell character of
the same size and vertical position as the start point, clamp the
selection line to the start line to avoid un-intuitive multiline
selections.
Fixes#8310
Store multi cell data in the CPUCell rather than in TextCache.
This sends the CPUCell size back to 12 but in benchmarks ASCII
performance is untouched and Unicode performace goes back to what it was
before multicell