mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-11-21 07:35:08 +00:00
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.
566 lines
23 KiB
C
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;
|
|
}
|