kitty/kitty/resize.c
Kovid Goyal cfd2b23dca
Fix out of bounds accesses with partially scrolled off multiline chars
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.
2026-11-13 10:43:13 +05:30

566 lines
23 KiB
C

/*
* resize.c
* Copyright (C) 2024 Kovid Goyal <kovid at kovidgoyal.net>
*
* Distributed under terms of the GPL3 license.
*/
#include "resize.h"
#include "lineops.h"
#define NAME bg_freq_map
#define KEY_TY uint32_t
#define VAL_TY uint32_t
#define HASH_FN vt_hash_integer
#define CMPR_FN vt_cmpr_integer
#include "kitty-verstable.h"
typedef struct Rewrap {
struct {
LineBuf *lb;
HistoryBuf *hb;
index_type x, y, hb_count;
Line line, scratch_line;
} src, dest;
ANSIBuf *as_ansi_buf;
TrackCursor *cursors;
LineBuf *sb;
index_type num_content_lines_before, src_x_limit;
bool prev_src_line_ended_with_wrap, current_src_line_has_multline_cells, current_dest_line_has_multiline_cells;
bool dest_line_from_linebuf, src_is_in_linebuf;
bool consume_src_hb;
} Rewrap;
static void
setup_line(TextCache *tc, index_type xnum, Line *l) {
l->text_cache = tc;
l->xnum = xnum;
}
#define src_xnum (r->src.lb->xnum)
#define dest_xnum (r->dest.lb->xnum)
static void
exclude_empty_lines_at_bottom(Rewrap *r) {
index_type first, i;
bool is_empty = true;
// Find the first line that contains some content
#define self (r->src.lb)
first = self->ynum;
do {
first--;
CPUCell *cells = linebuf_cpu_cells_for_line(self, first);
for (i = 0; i < self->xnum; i++) {
if (cells[i].ch_or_idx || cells[i].ch_is_idx) {
is_empty = false;
break;
}
}
} while (is_empty && first > 0);
if (!is_empty) r->num_content_lines_before = first + 1;
#undef self
}
static void
init_src_line_basic(Rewrap *r, index_type y, Line *dest, bool update_state) {
if (r->src_is_in_linebuf) {
linebuf_init_line_at(r->src.lb, y - r->src.hb_count, dest);
} else if (y >= r->src.hb_count) {
if (update_state) r->src_is_in_linebuf = true;
linebuf_init_line_at(r->src.lb, y - r->src.hb_count, dest);
} else {
// historybuf_init_line uses reverse indexing
historybuf_init_line(r->src.hb, r->src.hb->count - y - 1, dest);
}
}
static bool
init_src_line(Rewrap *r) {
bool newline_needed = !r->prev_src_line_ended_with_wrap;
init_src_line_basic(r, r->src.y, &r->src.line, true);
r->src_x_limit = src_xnum;
r->prev_src_line_ended_with_wrap = r->src.line.cpu_cells[src_xnum - 1].next_char_was_wrapped;
r->src.line.cpu_cells[src_xnum - 1].next_char_was_wrapped = false;
// Trim trailing blanks
while (r->src_x_limit && r->src.line.cpu_cells[r->src_x_limit - 1].ch_and_idx == BLANK_CHAR) r->src_x_limit--;
r->src.x = 0;
r->current_src_line_has_multline_cells = false;
for (index_type i = 0; i < r->src_x_limit; i++)
if (r->src.line.cpu_cells[i].is_multicell && r->src.line.cpu_cells[i].scale > 1) {
r->current_src_line_has_multline_cells = true;
break;
}
return newline_needed;
}
#define set_dest_line_attrs(dest_y) \
r->dest.lb->line_attrs[dest_y] = r->src.line.attrs; \
r->src.line.attrs.prompt_kind = UNKNOWN_PROMPT_KIND;
static void
first_dest_line(Rewrap *r) {
if (r->src.hb_count) {
historybuf_next_dest_line(r->dest.hb, r->as_ansi_buf, &r->src.line, 0, &r->dest.line, false);
r->src.line.attrs.prompt_kind = UNKNOWN_PROMPT_KIND;
} else {
r->dest_line_from_linebuf = true;
linebuf_init_line_at(r->dest.lb, 0, &r->dest.line);
set_dest_line_attrs(0);
}
}
static index_type
linebuf_next_dest_line(Rewrap *r, bool continued) {
#define dest_y r->dest.y
LineBuf *dest = r->dest.lb;
linebuf_set_last_char_as_continuation(dest, dest_y, continued);
if (dest_y >= dest->ynum - 1) {
linebuf_index(dest, 0, dest->ynum - 1);
if (r->dest.hb != NULL) {
linebuf_init_line(dest, dest->ynum - 1);
dest->line->attrs.has_dirty_text = true;
historybuf_add_line(r->dest.hb, dest->line, r->as_ansi_buf);
}
linebuf_clear_line(dest, dest->ynum - 1, true);
} else dest_y++;
linebuf_init_line_at(dest, dest_y, &r->dest.line);
set_dest_line_attrs(dest_y);
return dest_y;
#undef dest_y
}
static void
next_dest_line(Rewrap *r, bool continued) {
r->dest.x = 0;
r->current_dest_line_has_multiline_cells = false;
if (r->dest_line_from_linebuf) {
r->dest.y = linebuf_next_dest_line(r, continued);
} else if (r->src_is_in_linebuf) {
r->dest_line_from_linebuf = true;
r->dest.y = 0;
linebuf_init_line_at(r->dest.lb, 0, &r->dest.line);
set_dest_line_attrs(0);
if (continued && r->dest.hb && r->dest.hb->count) {
historybuf_init_line(r->dest.hb, 0, r->dest.hb->line);
r->dest.hb->line->cpu_cells[dest_xnum - 1].next_char_was_wrapped = true;
}
} else {
r->dest.y = historybuf_next_dest_line(r->dest.hb, r->as_ansi_buf, &r->src.line, r->dest.y, &r->dest.line, continued);
r->src.line.attrs.prompt_kind = UNKNOWN_PROMPT_KIND;
}
if (r->sb->line_attrs[0].has_dirty_text) {
CPUCell *cpu_cells;
GPUCell *gpu_cells;
linebuf_init_cells(r->sb, 0, &cpu_cells, &gpu_cells);
memcpy(r->dest.line.cpu_cells, cpu_cells, dest_xnum * sizeof(cpu_cells[0]));
memcpy(r->dest.line.gpu_cells, gpu_cells, dest_xnum * sizeof(gpu_cells[0]));
r->current_dest_line_has_multiline_cells = true;
}
linebuf_index(r->sb, 0, r->sb->ynum - 1);
if (r->sb->line_attrs[r->sb->ynum - 1].has_dirty_text) { linebuf_clear_line(r->sb, r->sb->ynum - 1, true); }
}
static void
update_tracked_cursors(Rewrap *r, index_type num_cells, index_type src_y, index_type dest_y, index_type x_limit) {
if (!r->src_is_in_linebuf) return;
src_y -= r->src.hb_count;
for (TrackCursor *t = r->cursors; !t->is_sentinel; t++) {
if (t->y == src_y && r->src.x <= t->x && (t->x < r->src.x + num_cells || t->x >= x_limit)) {
t->dest_y = dest_y;
t->dest_x = r->dest.x + (t->x - r->src.x);
if (t->dest_x > dest_xnum) t->dest_x = dest_xnum;
}
}
}
static void
update_tracked_cursors_for_dropped_cells(Rewrap *r, index_type num_cells) {
// Cursors on cells of src that are not copied to dest are placed where the
// cells would have been. As for update_tracked_cursors() cursors beyond the
// content of the src line are placed relative to the current position, in
// case nothing after the dropped cells is copied.
if (!r->src_is_in_linebuf) return;
const index_type src_y = r->src.y - r->src.hb_count;
for (TrackCursor *t = r->cursors; !t->is_sentinel; t++) {
if (t->y == src_y && r->src.x <= t->x) {
if (t->x < r->src.x + num_cells) {
t->dest_y = r->dest.y;
t->dest_x = MIN(r->dest.x, dest_xnum);
} else if (t->x >= r->src_x_limit) {
t->dest_y = r->dest.y;
t->dest_x = MIN(r->dest.x + (t->x - (r->src.x + num_cells)), dest_xnum);
}
}
}
}
static bool
find_space_in_dest_line(Rewrap *r, index_type num_cells) {
while (r->dest.x + num_cells <= dest_xnum) {
index_type before = r->dest.x;
for (index_type x = r->dest.x; x < r->dest.x + num_cells; x++) {
if (r->dest.line.cpu_cells[x].is_multicell) {
r->dest.x = x + mcd_x_limit(r->dest.line.cpu_cells + x);
break;
}
}
if (before == r->dest.x) return true;
}
return false;
}
static void
find_space_in_dest(Rewrap *r, index_type num_cells) {
while (!find_space_in_dest_line(r, num_cells)) next_dest_line(r, true);
}
static void
copy_range(Line *src, index_type src_at, Line *dest, index_type dest_at, index_type num) {
memcpy(dest->cpu_cells + dest_at, src->cpu_cells + src_at, num * sizeof(CPUCell));
memcpy(dest->gpu_cells + dest_at, src->gpu_cells + src_at, num * sizeof(GPUCell));
}
static void
copy_multiline_extra_lines(Rewrap *r, CPUCell *src_cell, index_type mc_width) {
// multiline_char_is_complete() has checked that all rows are present in src,
// the bound is kept so that this never reads out of bounds
const index_type num_src_lines = r->src.hb_count + r->src.lb->ynum;
for (index_type i = 1; i < src_cell->scale && r->src.y + i < num_src_lines; i++) {
init_src_line_basic(r, r->src.y + i, &r->src.scratch_line, false);
linebuf_init_line_at(r->sb, i - 1, &r->dest.scratch_line);
linebuf_mark_line_dirty(r->sb, i - 1);
copy_range(&r->src.scratch_line, r->src.x, &r->dest.scratch_line, r->dest.x, mc_width);
update_tracked_cursors(r, mc_width, r->src.y + i, r->dest.y + i, src_xnum + 10000 /* ensure cursor is moved only if in region being copied */);
}
}
static bool
multiline_char_is_complete(Rewrap *r, const CPUCell *src_cell) {
// whether all rows of the multiline char starting at src_cell are present in src, they
// can be missing if the char is partially scrolled off or torn
const CPUCell ref = *src_cell;
const index_type num_src_lines = r->src.hb_count + r->src.lb->ynum;
for (index_type i = 1; i < ref.scale; i++) {
if (r->src.y + i >= num_src_lines) return false;
init_src_line_basic(r, r->src.y + i, &r->src.scratch_line, false);
if (!continues_multicell_char(r->src.scratch_line.cpu_cells + r->src.x, &ref, i)) return false;
}
return true;
}
static void
multiline_copy_src_to_dest(Rewrap *r) {
CPUCell *c;
index_type mc_width;
while (r->src.x < r->src_x_limit) {
c = &r->src.line.cpu_cells[r->src.x];
if (c->is_multicell) {
mc_width = mcd_x_limit(c);
if (mc_width > dest_xnum) {
update_tracked_cursors(r, mc_width, r->src.y, r->dest.y, r->src_x_limit);
r->src.x += mc_width;
continue;
} else if (c->y) {
r->src.x += mc_width;
continue;
} else if (c->scale > 1 && !multiline_char_is_complete(r, c)) {
// partial multiline chars are dropped as they cannot be placed consistently in dest
update_tracked_cursors_for_dropped_cells(r, mc_width);
r->src.x += mc_width;
continue;
}
} else mc_width = 1;
find_space_in_dest(r, mc_width);
copy_range(&r->src.line, r->src.x, &r->dest.line, r->dest.x, mc_width);
update_tracked_cursors(r, mc_width, r->src.y, r->dest.y, r->src_x_limit);
if (c->scale > 1) copy_multiline_extra_lines(r, c, mc_width);
r->src.x += mc_width;
r->dest.x += mc_width;
}
}
static void
fast_copy_src_to_dest(Rewrap *r) {
CPUCell *c;
while (r->src.x < r->src_x_limit) {
if (r->dest.x >= dest_xnum) {
next_dest_line(r, true);
if (r->current_dest_line_has_multiline_cells) {
multiline_copy_src_to_dest(r);
return;
}
}
index_type num = MIN(r->src_x_limit - r->src.x, dest_xnum - r->dest.x);
if (num && (c = &r->src.line.cpu_cells[r->src.x + num - 1])->is_multicell && c->x != mcd_x_limit(c) - 1) {
// we have a split multicell at the right edge of the copy region
multiline_copy_src_to_dest(r);
return;
}
copy_range(&r->src.line, r->src.x, &r->dest.line, r->dest.x, num);
update_tracked_cursors(r, num, r->src.y, r->dest.y, r->src_x_limit);
r->src.x += num;
r->dest.x += num;
}
}
static void
rewrap(Rewrap *r) {
r->src.hb_count = r->src.hb ? r->src.hb->count : 0;
// Fast path
if (r->dest.lb->xnum == r->src.lb->xnum && r->dest.lb->ynum == r->src.lb->ynum) {
memcpy(r->dest.lb->line_map, r->src.lb->line_map, sizeof(index_type) * r->src.lb->ynum);
memcpy(r->dest.lb->line_attrs, r->src.lb->line_attrs, sizeof(LineAttrs) * r->src.lb->ynum);
memcpy(r->dest.lb->cpu_cell_buf, r->src.lb->cpu_cell_buf, (size_t)r->src.lb->xnum * r->src.lb->ynum * sizeof(CPUCell));
memcpy(r->dest.lb->gpu_cell_buf, r->src.lb->gpu_cell_buf, (size_t)r->src.lb->xnum * r->src.lb->ynum * sizeof(GPUCell));
r->num_content_lines_before = r->src.lb->ynum;
if (r->dest.hb && r->src.hb) historybuf_fast_rewrap(r->dest.hb, r->src.hb, r->src.hb->count, r->consume_src_hb);
r->dest.y = r->src.lb->ynum - 1;
return;
}
setup_line(r->src.lb->text_cache, src_xnum, &r->src.line);
setup_line(r->src.lb->text_cache, dest_xnum, &r->dest.line);
setup_line(r->src.lb->text_cache, src_xnum, &r->src.scratch_line);
setup_line(r->src.lb->text_cache, dest_xnum, &r->dest.scratch_line);
exclude_empty_lines_at_bottom(r);
for (; r->src.y < r->num_content_lines_before + r->src.hb_count; r->src.y++) {
if (init_src_line(r)) {
if (r->src.y) next_dest_line(r, false);
else first_dest_line(r);
}
if (r->current_src_line_has_multline_cells || r->current_dest_line_has_multiline_cells) multiline_copy_src_to_dest(r);
else fast_copy_src_to_dest(r);
}
// The lower rows of multiline chars are written to dest from sb when moving to
// the next dest line. If the src ended without that happening, for example,
// because the lines after a multiline char were continuations that fit on
// its first row, write out the remaining rows.
for (index_type i = 0; i < r->sb->ynum && r->sb->line_attrs[0].has_dirty_text; i++) next_dest_line(r, false);
}
static index_type
reusable_history_lines(HistoryBuf *hb) {
// count of oldest lines that rewrap to themselves at the same width
index_type xnum = hb->xnum, ans = 0;
bool prev_wrapped = false, prev_full = false;
Line l = {.xnum = xnum, .text_cache = hb->text_cache};
for (index_type y = 0; y + 1 < hb->count; y++) {
historybuf_init_line(hb, hb->count - y - 1, &l);
CPUCell *c = l.cpu_cells;
index_type limit = xnum;
while (limit && c[limit - 1].ch_and_idx == BLANK_CHAR) limit--;
if (prev_wrapped && (!prev_full || !limit)) return ans;
if (limit && c[limit - 1].is_multicell && c[limit - 1].x != mcd_x_limit(c + limit - 1) - 1) return ans;
for (index_type x = 0; x < limit; x++)
if (c[x].is_multicell && c[x].scale > 1) return ans;
prev_wrapped = c[xnum - 1].next_char_was_wrapped;
prev_full = limit == xnum;
if (!prev_wrapped) ans = y + 1;
}
return ans;
}
static void
clear_trailing_blanks(HistoryBuf *hb, index_type count) {
Line l = {.xnum = hb->xnum, .text_cache = hb->text_cache};
for (index_type y = 0; y < count; y++) {
historybuf_init_line(hb, hb->count - y - 1, &l);
index_type limit = l.xnum;
while (limit && l.cpu_cells[limit - 1].ch_and_idx == BLANK_CHAR) limit--;
zero_at_ptr_count(l.cpu_cells + limit, l.xnum - limit);
zero_at_ptr_count(l.gpu_cells + limit, l.xnum - limit);
}
}
ResizeResult
resize_screen_buffers(
LineBuf *lb, HistoryBuf *hb, HistoryResizeMode hb_mode, index_type lines, index_type columns, ANSIBuf *as_ansi_buf, TrackCursor *cursors) {
ResizeResult ans = {0};
ans.lb = alloc_linebuf(lines, columns, lb->text_cache);
if (!ans.lb) return ans;
RAII_PyObject(raii_nlb, (PyObject *)ans.lb);
(void)raii_nlb;
// sb holds the rows below the first row of multiline chars
static_assert((SCALE_BITS << 1) >= (1u << SCALE_BITS) - 2u, "sb is too small for the tallest multiline char");
LineBuf *sb = alloc_linebuf(SCALE_BITS << 1, columns, lb->text_cache);
if (!sb) return ans;
RAII_PyObject(scratch, (PyObject *)sb);
(void)scratch;
HistoryBuf *src_hb = hb;
index_type reused = 0;
RAII_PyObject(raii_tail, NULL);
if (hb) {
if (hb_mode == HISTORY_CONSUME && columns == lb->xnum && lines != lb->ynum) reused = reusable_history_lines(hb);
// copying a long tail would cost more than a plain rewrap
if (reused < hb->count - reused) reused = 0;
if (reused) {
src_hb = alloc_historybuf(hb->count - reused, columns, 0, hb->text_cache);
if (!src_hb) return ans;
raii_tail = (PyObject *)src_hb;
Line l = {.xnum = columns, .text_cache = hb->text_cache};
for (index_type y = reused; y < hb->count; y++) {
historybuf_init_line(hb, hb->count - y - 1, &l);
historybuf_add_line(src_hb, &l, as_ansi_buf);
}
}
ans.hb = historybuf_alloc_for_rewrap(columns, hb);
if (!ans.hb) return ans;
}
// Nothing below this point may fail, as hb is modified and, with
// HISTORY_CONSUME, its storage is moved into ans.hb, both here and in the
// fast path of rewrap(). All allocations must be done above.
if (reused) {
clear_trailing_blanks(hb, reused);
historybuf_fast_rewrap(ans.hb, hb, reused, true);
}
RAII_PyObject(raii_nhb, (PyObject *)ans.hb);
(void)raii_nhb;
Rewrap r = {
.src = {.lb = lb, .hb = src_hb},
.dest = {.lb = ans.lb, .hb = ans.hb, .y = reused},
.as_ansi_buf = as_ansi_buf,
.cursors = cursors,
.sb = sb,
.consume_src_hb = hb_mode != HISTORY_PRESERVE,
};
for (TrackCursor *t = cursors; !t->is_sentinel; t++) {
t->dest_x = t->x;
t->dest_y = t->y;
}
rewrap(&r);
ans.num_content_lines_before = r.num_content_lines_before;
ans.num_content_lines_after = MIN(r.dest.y + 1, ans.lb->ynum);
if (hb) historybuf_finish_rewrap(ans.hb, hb);
for (unsigned i = 0; i < ans.num_content_lines_after; i++) linebuf_mark_line_dirty(ans.lb, i);
for (TrackCursor *t = cursors; !t->is_sentinel; t++) {
t->dest_x = MIN(t->dest_x, columns);
t->dest_y = MIN(t->dest_y, lines);
}
Py_INCREF(raii_nlb);
Py_XINCREF(raii_nhb);
ans.ok = true;
return ans;
}
static void
nuke_in_line(CPUCell *cp, GPUCell *gp, index_type start, index_type x_limit) {
for (index_type x = start; x < x_limit; x++) {
cell_set_char(cp + x, 0);
cp[x].is_multicell = false;
clear_sprite_position(gp[x]);
}
}
static void
nuke_multicell_char_at(LineBuf *lb, index_type x_, index_type y_) {
CPUCell *cp;
GPUCell *gp;
linebuf_init_cells(lb, y_, &cp, &gp);
const CPUCell ref = cp[x_];
// only the adjacent rows that continue the char, as it may be partial or torn
index_type y_start = y_, y_limit = y_ + 1;
while (y_start > 0 && y_ - y_start < ref.y && continues_multicell_char(linebuf_cpu_cells_for_line(lb, y_start - 1) + x_, &ref, ref.y - (y_ - y_start) - 1))
y_start--;
while (y_limit < lb->ynum && y_limit - y_ + ref.y < ref.scale &&
continues_multicell_char(linebuf_cpu_cells_for_line(lb, y_limit) + x_, &ref, ref.y + (y_limit - y_)))
y_limit++;
while (cp[x_].x && x_ > 0) x_--;
index_type x_limit = MIN(lb->xnum, x_ + mcd_x_limit(&cp[x_]));
for (index_type y = y_start; y < y_limit; y++) {
linebuf_init_cells(lb, y, &cp, &gp);
nuke_in_line(cp, gp, x_, x_limit);
}
}
ResizeResult
resize_screen_buffer_without_rewrap(LineBuf *lb, index_type lines, index_type columns, TrackCursor *cursors) {
ResizeResult ans = {0};
ans.lb = alloc_linebuf(lines, columns, lb->text_cache);
if (!ans.lb) return ans;
Rewrap r = {
.src = {.lb = lb},
};
exclude_empty_lines_at_bottom(&r);
ans.num_content_lines_before = r.num_content_lines_before;
ans.num_content_lines_after = MIN(lines, r.num_content_lines_before);
index_type xcommon = MIN(lb->xnum, ans.lb->xnum);
for (index_type y = 0; y < ans.num_content_lines_after; y++) {
linebuf_init_line(lb, y);
linebuf_init_line(ans.lb, y);
ans.lb->line_attrs[y] = lb->line_attrs[y];
ans.lb->line_attrs[y].has_dirty_text = true;
memcpy(ans.lb->line->cpu_cells, lb->line->cpu_cells, xcommon * sizeof(lb->line->cpu_cells[0]));
memcpy(ans.lb->line->gpu_cells, lb->line->gpu_cells, xcommon * sizeof(lb->line->gpu_cells[0]));
if (xcommon > lb->line->xnum) {
// extend the colors/styles of the last cell to edge
GPUCell e = lb->line->gpu_cells[xcommon - 1];
clear_sprite_position(e);
for (index_type x = xcommon; x < ans.lb->line->xnum; x++) ans.lb->line->gpu_cells[x] = e;
} else if (xcommon < lb->line->xnum) {
// remove multicell chars that were split at the right edge
index_type last_x = xcommon - 1;
CPUCell *c = ans.lb->line->cpu_cells + last_x;
if (c->is_multicell && c->x + 1u < mcd_x_limit(c)) {
while (ans.lb->line->cpu_cells[last_x].x && last_x > 0) last_x--;
nuke_in_line(ans.lb->line->cpu_cells, ans.lb->line->gpu_cells, last_x, ans.lb->line->xnum);
}
}
}
// Fill new empty lines at the bottom with the most common background color
// from the existing content, so expanding the screen looks visually smooth
// without flashing app-specific colors (e.g. a statusline at the last row).
if (ans.num_content_lines_before < lines) {
uint32_t fill_bg = 0;
bg_freq_map freq;
vt_init(&freq);
for (index_type y = 0; y < ans.num_content_lines_after; y++) {
CPUCell *cp;
GPUCell *gp;
linebuf_init_cells(lb, y, &cp, &gp);
for (index_type x = 0; x < lb->xnum; x++) {
bg_freq_map_itr itr = vt_get_or_insert(&freq, gp[x].bg, 0);
if (!vt_is_end(itr)) itr.data->val++;
}
}
uint32_t best_count = 0;
vt_create_for_loop(bg_freq_map_itr, itr, &freq) {
if (itr.data->val > best_count) {
best_count = itr.data->val;
fill_bg = itr.data->key;
}
}
vt_cleanup(&freq);
if (fill_bg) {
for (index_type y = ans.num_content_lines_after; y < ans.lb->ynum; y++) {
linebuf_init_line(ans.lb, y);
for (index_type x = 0; x < ans.lb->xnum; x++) ans.lb->line->gpu_cells[x].bg = fill_bg;
}
}
}
if (ans.num_content_lines_after && (ans.num_content_lines_after < ans.num_content_lines_before || ans.num_content_lines_after < lines)) {
// delete multicell chars split at the bottom, and chars that were cut
// off at the bottom of the screen but no longer are, as there are now
// lines below them
linebuf_init_line(ans.lb, ans.num_content_lines_after - 1);
for (index_type x = 0; x < ans.lb->xnum; x++) {
CPUCell *c = ans.lb->line->cpu_cells + x;
if (c->is_multicell && c->y < c->scale - 1) nuke_multicell_char_at(ans.lb, x, ans.num_content_lines_after - 1);
}
}
for (TrackCursor *tc = cursors; !tc->is_sentinel; tc++) {
tc->dest_x = MIN(tc->x, ans.lb->xnum - 1);
tc->dest_y = MIN(tc->y, ans.lb->ynum - 1);
}
ans.ok = true;
return ans;
}