mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-05 04:06:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
foot/grid.c

859 lines
27 KiB
C
Raw Normal View History

wip: vt parsing: break out grid operating functions
2019-06-17 19:33:10 +02:00
#include "grid.h"
grid: include <stdlib.h>, for qsort_r()
2021-05-15 13:32:10 +02:00
#include <stdlib.h>
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
#include <string.h>
grid: track both linear and row,col cursor
2019-06-17 21:15:20 +02:00
wip: initial scrolling support (no scrollback though)
2019-06-19 10:27:31 +02:00
#define LOG_MODULE "grid"
logging: disable debug logging by default
2019-07-03 20:21:03 +02:00
#define LOG_ENABLE_DBG 0
wip: initial scrolling support (no scrollback though)
2019-06-19 10:27:31 +02:00
#include "log.h"
Print stack trace on assert() failure or when calling fatal_error() Note: this uses the __sanitizer_print_stack_trace() function from the AddressSanitizer runtime, so it only works when AddressSanitizer is in use.
2021-01-15 20:39:45 +00:00
#include "debug.h"
grid: reflow: fix release build; ‘idx’ is only used in an assert()
2020-09-24 18:53:05 +02:00
#include "macros.h"
sixel: improve handling of images when reflowing the grids Update the sixels' 'row' attribute when re-flowing a grid, to ensure it is rendered at the correct place. This should work in most cases, but will break when the cell size has changed (e.g. font size increase/decrease, or a DPI change). This patch also moves the sixel image list from the terminal struct into the grid struct. The sixels are per-grid after all.
2020-03-13 18:44:23 +01:00
#include "sixel.h"
grid: add grid_snapshot() This function deep copies a grid into a newly *allocated* grid struct.
2021-02-22 10:21:58 +01:00
#include "stride.h"
util.h: new header file defining commonly used macros
2020-05-01 11:46:24 +02:00
#include "util.h"
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
#include "xmalloc.h"
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
grid: disable reflow timing by default
2021-05-26 12:22:28 +02:00
#define TIME_REFLOW 0
grid: add compile-time define to enable timing of the reflow operation
2021-05-11 17:43:17 +02:00
grid: add grid_snapshot() This function deep copies a grid into a newly *allocated* grid struct.
2021-02-22 10:21:58 +01:00
struct grid *
grid_snapshot(const struct grid *grid)
{
struct grid *clone = xmalloc(sizeof(*clone));
clone->num_rows = grid->num_rows;
clone->num_cols = grid->num_cols;
clone->offset = grid->offset;
clone->view = grid->view;
clone->cursor = grid->cursor;
clone->rows = xcalloc(grid->num_rows, sizeof(clone->rows[0]));
memset(&clone->scroll_damage, 0, sizeof(clone->scroll_damage));
memset(&clone->sixel_images, 0, sizeof(clone->sixel_images));
grid: snapshot: copy scroll damage
2021-02-22 10:31:56 +01:00
tll_foreach(grid->scroll_damage, it)
tll_push_back(clone->scroll_damage, it->item);
grid: add grid_snapshot() This function deep copies a grid into a newly *allocated* grid struct.
2021-02-22 10:21:58 +01:00
for (int r = 0; r < grid->num_rows; r++) {
const struct row *row = grid->rows[r];
if (row == NULL)
continue;
struct row *clone_row = xmalloc(sizeof(*row));
clone->rows[r] = clone_row;
clone_row->cells = xmalloc(grid->num_cols * sizeof(clone_row->cells[0]));
clone_row->linebreak = row->linebreak;
csi: remove extra ‘;’
2021-02-26 09:25:17 +01:00
clone_row->dirty = row->dirty;
grid: add grid_snapshot() This function deep copies a grid into a newly *allocated* grid struct.
2021-02-22 10:21:58 +01:00
grid: snapshot: don’t mark all cells as dirty - copy state from source grid
2021-02-26 09:25:27 +01:00
for (int c = 0; c < grid->num_cols; c++)
grid: add grid_snapshot() This function deep copies a grid into a newly *allocated* grid struct.
2021-02-22 10:21:58 +01:00
clone_row->cells[c] = row->cells[c];
if (row->extra != NULL) {
const struct row_data *extra = row->extra;
struct row_data *new_extra = xcalloc(1, sizeof(*new_extra));
tll_foreach(extra->uri_ranges, it) {
struct row_uri_range range = {
.start = it->item.start,
.end = it->item.end,
.id = it->item.id,
.uri = xstrdup(it->item.uri),
};
tll_push_back(new_extra->uri_ranges, range);
}
clone_row->extra = new_extra;
} else
clone_row->extra = NULL;
}
tll_foreach(grid->sixel_images, it) {
int width = it->item.width;
int height = it->item.height;
pixman_image_t *pix = it->item.pix;
pixman_format_code_t pix_fmt = pixman_image_get_format(pix);
int stride = stride_for_format_and_width(pix_fmt, width);
size_t size = stride * height;
void *new_data = xmalloc(size);
memcpy(new_data, it->item.data, size);
pixman_image_t *new_pix = pixman_image_create_bits_no_clear(
pix_fmt, width, height, new_data, stride);
struct sixel six = {
.data = new_data,
.pix = new_pix,
.width = width,
.height = height,
.rows = it->item.rows,
.cols = it->item.cols,
.pos = it->item.pos,
};
tll_push_back(clone->sixel_images, six);
}
return clone;
}
grid: add grid_free()
2021-02-22 10:20:52 +01:00
void
grid_free(struct grid *grid)
{
for (int r = 0; r < grid->num_rows; r++)
grid_row_free(grid->rows[r]);
tll_foreach(grid->sixel_images, it) {
sixel_destroy(&it->item);
tll_remove(grid->sixel_images, it);
}
free(grid->rows);
grid: grid_free(): free scroll damage list
2021-02-22 10:31:40 +01:00
tll_free(grid->scroll_damage);
grid: add grid_free()
2021-02-22 10:20:52 +01:00
}
wip: use a sliding window instead of memmove() to scroll Instead of memmoving a large amount of data on every scroll, use a sliding window. That is, each time we scroll, we offset origin.
2019-07-01 12:23:38 +02:00
void
grid: swap_row: remove unused parameter 'initialize'
2020-05-16 23:43:05 +02:00
grid_swap_row(struct grid *grid, int row_a, int row_b)
wip: use a sliding window instead of memmove() to scroll Instead of memmoving a large amount of data on every scroll, use a sliding window. That is, each time we scroll, we offset origin.
2019-07-01 12:23:38 +02:00
{
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(grid->offset >= 0);
xassert(row_a != row_b);
grid: implement a memmove-sort-of function grid_memmove() moves cell data from one index to another, taking the grid offset into account.
2019-07-01 19:18:52 +02:00
scrolling: optimize row access by assuming number of rows is a power of 2 With this assumption, we can replace 'a % b' with 'a & (b - 1)'. In terms of instructions, this means a fast 'and' instead of a slow 'div'. Further optimize scrolling by: * not double-initializing empty rows. Previously, grid_row_alloc() called calloc(), which was then followed by a memset() when scrolling. This is of course unnecessary. * Don't loop the entire set of visible rows (this was done to ensure all visible rows had been allocated, and to prefetch the cell contents). This isn't necessary; only newly pulled in rows can be NULL. For now, don't prefetch at all.
2019-08-22 17:33:23 +02:00
int real_a = (grid->offset + row_a) & (grid->num_rows - 1);
int real_b = (grid->offset + row_b) & (grid->num_rows - 1);
struct row *a = grid->rows[real_a];
struct row *b = grid->rows[real_b];
grid: remove commented out code
2019-08-23 20:07:27 +02:00
scrolling: optimize row access by assuming number of rows is a power of 2 With this assumption, we can replace 'a % b' with 'a & (b - 1)'. In terms of instructions, this means a fast 'and' instead of a slow 'div'. Further optimize scrolling by: * not double-initializing empty rows. Previously, grid_row_alloc() called calloc(), which was then followed by a memset() when scrolling. This is of course unnecessary. * Don't loop the entire set of visible rows (this was done to ensure all visible rows had been allocated, and to prefetch the cell contents). This isn't necessary; only newly pulled in rows can be NULL. For now, don't prefetch at all.
2019-08-22 17:33:23 +02:00
grid->rows[real_a] = b;
grid->rows[real_b] = a;
grid: implement a memmove-sort-of function grid_memmove() moves cell data from one index to another, taking the grid offset into account.
2019-07-01 19:18:52 +02:00
}
grid: don't pre-allocate the entire grid (with all scrollback lines) The row array may now contain NULL pointers. This means the corresponding row hasn't yet been allocated and initialized. On a resize, we explicitly allocate the visible rows. Uninitialized rows are then allocated the first time they are referenced.
2019-07-10 16:27:55 +02:00
struct row *
scrolling: optimize row access by assuming number of rows is a power of 2 With this assumption, we can replace 'a % b' with 'a & (b - 1)'. In terms of instructions, this means a fast 'and' instead of a slow 'div'. Further optimize scrolling by: * not double-initializing empty rows. Previously, grid_row_alloc() called calloc(), which was then followed by a memset() when scrolling. This is of course unnecessary. * Don't loop the entire set of visible rows (this was done to ensure all visible rows had been allocated, and to prefetch the cell contents). This isn't necessary; only newly pulled in rows can be NULL. For now, don't prefetch at all.
2019-08-22 17:33:23 +02:00
grid_row_alloc(int cols, bool initialize)
grid: don't pre-allocate the entire grid (with all scrollback lines) The row array may now contain NULL pointers. This means the corresponding row hasn't yet been allocated and initialized. On a resize, we explicitly allocate the visible rows. Uninitialized rows are then allocated the first time they are referenced.
2019-07-10 16:27:55 +02:00
{
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
struct row *row = xmalloc(sizeof(*row));
scrolling: optimize row access by assuming number of rows is a power of 2 With this assumption, we can replace 'a % b' with 'a & (b - 1)'. In terms of instructions, this means a fast 'and' instead of a slow 'div'. Further optimize scrolling by: * not double-initializing empty rows. Previously, grid_row_alloc() called calloc(), which was then followed by a memset() when scrolling. This is of course unnecessary. * Don't loop the entire set of visible rows (this was done to ensure all visible rows had been allocated, and to prefetch the cell contents). This isn't necessary; only newly pulled in rows can be NULL. For now, don't prefetch at all.
2019-08-22 17:33:23 +02:00
row->dirty = false;
term: convert cell 'linefeed' attribute to a row 'linebreak' property To do text reflow, we only need to know if a line has been explicitly linebreaked or not. If not, that means it wrapped, and that we should *not* insert a linebreak when reflowing text. When reflowing text, when reaching the end of a row in the old grid, only insert a linebreak in the new grid if the old row had been explicitly linebreaked. Furthermore, when reflowing text and wrapping a row in the new grid, mark the previous row as linebreaked if either the last cell was (the last column in the last row) empty, or the current cell (the first column in the new row) is empty. If both are non-empty, then we assume a linewrap.
2020-02-14 22:39:26 +01:00
row->linebreak = false;
grid: enable rows to have ‘extra’ data associated with them This patch adds an ‘extra’ member to the row struct. It is a pointer to a struct containing extra data to be associated with this row. Initially, this struct contains a list of URL ranges. These define (OSC-8) URLs on this row. The ‘extra’ data is allocated on-demand. I.e. the pointer is NULL by default; it is *not* allocated by grid_row_alloc().
2021-02-13 12:31:55 +01:00
row->extra = NULL;
scrolling: optimize row access by assuming number of rows is a power of 2 With this assumption, we can replace 'a % b' with 'a & (b - 1)'. In terms of instructions, this means a fast 'and' instead of a slow 'div'. Further optimize scrolling by: * not double-initializing empty rows. Previously, grid_row_alloc() called calloc(), which was then followed by a memset() when scrolling. This is of course unnecessary. * Don't loop the entire set of visible rows (this was done to ensure all visible rows had been allocated, and to prefetch the cell contents). This isn't necessary; only newly pulled in rows can be NULL. For now, don't prefetch at all.
2019-08-22 17:33:23 +02:00
if (initialize) {
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
row->cells = xcalloc(cols, sizeof(row->cells[0]));
scrolling: optimize row access by assuming number of rows is a power of 2 With this assumption, we can replace 'a % b' with 'a & (b - 1)'. In terms of instructions, this means a fast 'and' instead of a slow 'div'. Further optimize scrolling by: * not double-initializing empty rows. Previously, grid_row_alloc() called calloc(), which was then followed by a memset() when scrolling. This is of course unnecessary. * Don't loop the entire set of visible rows (this was done to ensure all visible rows had been allocated, and to prefetch the cell contents). This isn't necessary; only newly pulled in rows can be NULL. For now, don't prefetch at all.
2019-08-22 17:33:23 +02:00
for (size_t c = 0; c < cols; c++)
row->cells[c].attrs.clean = 1;
unicode-combining: store seen combining chains "globally" in the term struct Instead of storing combining data per cell, realize that most combinations are re-occurring and that there's lots of available space left in the unicode range, and store seen base+combining combinations chains in a per-terminal array. When we encounter a combining character, we first try to pre-compose, like before. If that fails, we then search for the current base+combining combo in the list of previously seen combinations. If not found there either, we allocate a new combo and add it to the list. Regardless, the result is an index into this array. We store this index, offsetted by COMB_CHARS_LO=0x40000000ul in the cell. When rendering, we need to check if the cell character is a plain character, or if it's a composed character (identified by checking if the cell character is >= COMB_CHARS_LO). Then we render the grapheme pretty much like before.
2020-05-03 11:03:22 +02:00
} else
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
row->cells = xmalloc(cols * sizeof(row->cells[0]));
scrolling: optimize row access by assuming number of rows is a power of 2 With this assumption, we can replace 'a % b' with 'a & (b - 1)'. In terms of instructions, this means a fast 'and' instead of a slow 'div'. Further optimize scrolling by: * not double-initializing empty rows. Previously, grid_row_alloc() called calloc(), which was then followed by a memset() when scrolling. This is of course unnecessary. * Don't loop the entire set of visible rows (this was done to ensure all visible rows had been allocated, and to prefetch the cell contents). This isn't necessary; only newly pulled in rows can be NULL. For now, don't prefetch at all.
2019-08-22 17:33:23 +02:00
grid: don't pre-allocate the entire grid (with all scrollback lines) The row array may now contain NULL pointers. This means the corresponding row hasn't yet been allocated and initialized. On a resize, we explicitly allocate the visible rows. Uninitialized rows are then allocated the first time they are referenced.
2019-07-10 16:27:55 +02:00
return row;
}
void
grid_row_free(struct row *row)
{
if (row == NULL)
return;
grid: grid_row_free(): use grid_row_reset_extra()
2021-02-14 20:34:25 +01:00
grid_row_reset_extra(row);
grid: enable rows to have ‘extra’ data associated with them This patch adds an ‘extra’ member to the row struct. It is a pointer to a struct containing extra data to be associated with this row. Initially, this struct contains a list of URL ranges. These define (OSC-8) URLs on this row. The ‘extra’ data is allocated on-demand. I.e. the pointer is NULL by default; it is *not* allocated by grid_row_alloc().
2021-02-13 12:31:55 +01:00
free(row->extra);
grid: don't pre-allocate the entire grid (with all scrollback lines) The row array may now contain NULL pointers. This means the corresponding row hasn't yet been allocated and initialized. On a resize, we explicitly allocate the visible rows. Uninitialized rows are then allocated the first time they are referenced.
2019-07-10 16:27:55 +02:00
free(row->cells);
free(row);
}
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
grid: grid_reflow() now translates cursor coordinates
2020-04-16 19:38:30 +02:00
void
resize: don’t reflow text on alt screen Alt screen applications normally reflow/readjust themselves on a window resize. When we do it too, the result is graphical glitches/flashes since our re-flowed text is rendered in one frame, and the application re-flowed text soon thereafter. We can’t avoid rendering some kind of re-flowed frame, since we don’t know when, or even if, the application will update itself. To avoid glitches, we need to render, as closely as possible, what the application itself will render shortly. This is actually pretty simple; we just need to copy the visible content over from the old grid to the new grid. We don’t bother with text re-flow, but simply truncate long lines. To simplify things, we simply cancel any active selection (since often times, it will be corrupted anyway when the application redraws itself). Since we’re not reflowing text, there’s no need to translate e.g. the cursor position - we just keep the current position (but bounded to the new dimensions). Fun thing: ‘less’ gets corrupted if we don’t leave the cursor at the (new) bottom row. To handle this, we check if the cursor (before resize) is at the bottom row, and if so, we move it to the new bottom row. Closes #221
2020-11-24 19:00:57 +01:00
grid_resize_without_reflow(
struct grid *grid, int new_rows, int new_cols,
int old_screen_rows, int new_screen_rows)
{
struct row *const *old_grid = grid->rows;
const int old_rows = grid->num_rows;
const int old_cols = grid->num_cols;
struct row **new_grid = xcalloc(new_rows, sizeof(new_grid[0]));
tll(struct sixel) untranslated_sixels = tll_init();
tll_foreach(grid->sixel_images, it)
tll_push_back(untranslated_sixels, it->item);
tll_free(grid->sixel_images);
int new_offset = 0;
/* Copy old lines, truncating them if old rows were longer */
grid: resize_without_reflow: don’t call min() on every loop iteration
2020-11-25 20:33:07 +01:00
for (int r = 0, n = min(old_screen_rows, new_screen_rows); r < n; r++) {
resize: don’t reflow text on alt screen Alt screen applications normally reflow/readjust themselves on a window resize. When we do it too, the result is graphical glitches/flashes since our re-flowed text is rendered in one frame, and the application re-flowed text soon thereafter. We can’t avoid rendering some kind of re-flowed frame, since we don’t know when, or even if, the application will update itself. To avoid glitches, we need to render, as closely as possible, what the application itself will render shortly. This is actually pretty simple; we just need to copy the visible content over from the old grid to the new grid. We don’t bother with text re-flow, but simply truncate long lines. To simplify things, we simply cancel any active selection (since often times, it will be corrupted anyway when the application redraws itself). Since we’re not reflowing text, there’s no need to translate e.g. the cursor position - we just keep the current position (but bounded to the new dimensions). Fun thing: ‘less’ gets corrupted if we don’t leave the cursor at the (new) bottom row. To handle this, we check if the cursor (before resize) is at the bottom row, and if so, we move it to the new bottom row. Closes #221
2020-11-24 19:00:57 +01:00
const int old_row_idx = (grid->offset + r) & (old_rows - 1);
const int new_row_idx = (new_offset + r) & (new_rows - 1);
const struct row *old_row = old_grid[old_row_idx];
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(old_row != NULL);
resize: don’t reflow text on alt screen Alt screen applications normally reflow/readjust themselves on a window resize. When we do it too, the result is graphical glitches/flashes since our re-flowed text is rendered in one frame, and the application re-flowed text soon thereafter. We can’t avoid rendering some kind of re-flowed frame, since we don’t know when, or even if, the application will update itself. To avoid glitches, we need to render, as closely as possible, what the application itself will render shortly. This is actually pretty simple; we just need to copy the visible content over from the old grid to the new grid. We don’t bother with text re-flow, but simply truncate long lines. To simplify things, we simply cancel any active selection (since often times, it will be corrupted anyway when the application redraws itself). Since we’re not reflowing text, there’s no need to translate e.g. the cursor position - we just keep the current position (but bounded to the new dimensions). Fun thing: ‘less’ gets corrupted if we don’t leave the cursor at the (new) bottom row. To handle this, we check if the cursor (before resize) is at the bottom row, and if so, we move it to the new bottom row. Closes #221
2020-11-24 19:00:57 +01:00
struct row *new_row = grid_row_alloc(new_cols, false);
new_grid[new_row_idx] = new_row;
memcpy(new_row->cells,
old_row->cells,
sizeof(struct cell) * min(old_cols, new_cols));
new_row->dirty = old_row->dirty;
new_row->linebreak = false;
if (new_cols > old_cols) {
grid: don’t cut multi-column chars in half when resizing the alt screen When we resize the alt screen, we don’t reflow the text, we simply truncate all the lines. When doing this, make sure we don’t truncate in the middle of a multi-column character.
2021-06-02 19:32:05 +02:00
/* Clear "new" columns */
resize: don’t reflow text on alt screen Alt screen applications normally reflow/readjust themselves on a window resize. When we do it too, the result is graphical glitches/flashes since our re-flowed text is rendered in one frame, and the application re-flowed text soon thereafter. We can’t avoid rendering some kind of re-flowed frame, since we don’t know when, or even if, the application will update itself. To avoid glitches, we need to render, as closely as possible, what the application itself will render shortly. This is actually pretty simple; we just need to copy the visible content over from the old grid to the new grid. We don’t bother with text re-flow, but simply truncate long lines. To simplify things, we simply cancel any active selection (since often times, it will be corrupted anyway when the application redraws itself). Since we’re not reflowing text, there’s no need to translate e.g. the cursor position - we just keep the current position (but bounded to the new dimensions). Fun thing: ‘less’ gets corrupted if we don’t leave the cursor at the (new) bottom row. To handle this, we check if the cursor (before resize) is at the bottom row, and if so, we move it to the new bottom row. Closes #221
2020-11-24 19:00:57 +01:00
memset(&new_row->cells[old_cols], 0,
sizeof(struct cell) * (new_cols - old_cols));
new_row->dirty = true;
grid: don’t cut multi-column chars in half when resizing the alt screen When we resize the alt screen, we don’t reflow the text, we simply truncate all the lines. When doing this, make sure we don’t truncate in the middle of a multi-column character.
2021-06-02 19:32:05 +02:00
} else if (old_cols > new_cols) {
/* Make sure we don't cut a multi-column character in two */
for (int i = new_cols; i > 0 && old_row->cells[i].wc > CELL_SPACER; i--)
new_row->cells[i - 1].wc = 0;
resize: don’t reflow text on alt screen Alt screen applications normally reflow/readjust themselves on a window resize. When we do it too, the result is graphical glitches/flashes since our re-flowed text is rendered in one frame, and the application re-flowed text soon thereafter. We can’t avoid rendering some kind of re-flowed frame, since we don’t know when, or even if, the application will update itself. To avoid glitches, we need to render, as closely as possible, what the application itself will render shortly. This is actually pretty simple; we just need to copy the visible content over from the old grid to the new grid. We don’t bother with text re-flow, but simply truncate long lines. To simplify things, we simply cancel any active selection (since often times, it will be corrupted anyway when the application redraws itself). Since we’re not reflowing text, there’s no need to translate e.g. the cursor position - we just keep the current position (but bounded to the new dimensions). Fun thing: ‘less’ gets corrupted if we don’t leave the cursor at the (new) bottom row. To handle this, we check if the cursor (before resize) is at the bottom row, and if so, we move it to the new bottom row. Closes #221
2020-11-24 19:00:57 +01:00
}
/* Map sixels on current "old" row to current "new row" */
tll_foreach(untranslated_sixels, it) {
if (it->item.pos.row != old_row_idx)
continue;
struct sixel sixel = it->item;
sixel.pos.row = new_row_idx;
if (sixel.pos.col < new_cols)
tll_push_back(grid->sixel_images, sixel);
else
sixel_destroy(&it->item);
tll_remove(untranslated_sixels, it);
}
grid: grid_resize_without_reflow: transfer URI ranges
2021-02-14 20:42:42 +01:00
/* Copy URI ranges, truncating them if necessary */
if (old_row->extra == NULL)
continue;
tll_foreach(old_row->extra->uri_ranges, it) {
if (it->item.start >= new_rows) {
/* The whole range is truncated */
continue;
}
struct row_uri_range range = {
.start = it->item.start,
.end = min(it->item.end, new_cols - 1),
.id = it->item.id,
.uri = xstrdup(it->item.uri),
};
grid: refactor: use grid_row_add_uri_range()
2021-02-14 20:50:46 +01:00
grid_row_add_uri_range(new_row, range);
grid: grid_resize_without_reflow: transfer URI ranges
2021-02-14 20:42:42 +01:00
}
resize: don’t reflow text on alt screen Alt screen applications normally reflow/readjust themselves on a window resize. When we do it too, the result is graphical glitches/flashes since our re-flowed text is rendered in one frame, and the application re-flowed text soon thereafter. We can’t avoid rendering some kind of re-flowed frame, since we don’t know when, or even if, the application will update itself. To avoid glitches, we need to render, as closely as possible, what the application itself will render shortly. This is actually pretty simple; we just need to copy the visible content over from the old grid to the new grid. We don’t bother with text re-flow, but simply truncate long lines. To simplify things, we simply cancel any active selection (since often times, it will be corrupted anyway when the application redraws itself). Since we’re not reflowing text, there’s no need to translate e.g. the cursor position - we just keep the current position (but bounded to the new dimensions). Fun thing: ‘less’ gets corrupted if we don’t leave the cursor at the (new) bottom row. To handle this, we check if the cursor (before resize) is at the bottom row, and if so, we move it to the new bottom row. Closes #221
2020-11-24 19:00:57 +01:00
}
/* Clear "new" lines */
for (int r = min(old_screen_rows, new_screen_rows); r < new_screen_rows; r++) {
struct row *new_row = grid_row_alloc(new_cols, false);
new_grid[(new_offset + r) & (new_rows - 1)] = new_row;
memset(new_row->cells, 0, sizeof(struct cell) * new_cols);
new_row->dirty = true;
}
/* Free old grid */
for (int r = 0; r < grid->num_rows; r++)
grid_row_free(old_grid[r]);
free(grid->rows);
grid->rows = new_grid;
grid->num_rows = new_rows;
grid->num_cols = new_cols;
grid->view = grid->offset = new_offset;
/* Keep cursor at current position, but clamp to new dimensions */
struct coord cursor = grid->cursor.point;
if (cursor.row == old_screen_rows - 1) {
/* 'less' breaks if the cursor isn't at the bottom */
cursor.row = new_screen_rows - 1;
}
cursor.row = min(cursor.row, new_screen_rows - 1);
cursor.col = min(cursor.col, new_cols - 1);
grid->cursor.point = cursor;
struct coord saved_cursor = grid->saved_cursor.point;
if (saved_cursor.row == old_screen_rows - 1)
saved_cursor.row = new_screen_rows - 1;
saved_cursor.row = min(saved_cursor.row, new_screen_rows - 1);
saved_cursor.col = min(saved_cursor.col, new_cols - 1);
grid->saved_cursor.point = saved_cursor;
grid->cur_row = new_grid[(grid->offset + cursor.row) & (new_rows - 1)];
grid->cursor.lcf = false;
grid->saved_cursor.lcf = false;
/* Free sixels we failed to "map" to the new grid */
tll_foreach(untranslated_sixels, it)
sixel_destroy(&it->item);
tll_free(untranslated_sixels);
#if defined(_DEBUG)
for (int r = 0; r < new_screen_rows; r++)
grid_row_in_view(grid, r);
#endif
}
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
static void
grid: reflow: uri-ranges: avoid looping URI ranges when reflowing Since we know the following: * URI ranges are sorted * URI coordinates are unique * URI ranges don’t cross rows We can optimize URI range reflowing by: * Checking if the *first* URI range’s start coordinate is on the current column. If so, keep a pointer to it. * Use this pointer as source when instantiating the reflowed URI range * If we already have a non-NULL range pointer, check its end coordinate instead. * If it matches, close the *last* URI range we inserted on the new row, and free/remove the range from the old row. * When line breaking, we only need to check if the *last* URI range is unclosed.
2021-05-22 20:29:10 +02:00
reflow_uri_range_start(struct row_uri_range *range, struct row *new_row,
int new_col_idx)
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
{
grid: reflow: uri-ranges: avoid looping URI ranges when reflowing Since we know the following: * URI ranges are sorted * URI coordinates are unique * URI ranges don’t cross rows We can optimize URI range reflowing by: * Checking if the *first* URI range’s start coordinate is on the current column. If so, keep a pointer to it. * Use this pointer as source when instantiating the reflowed URI range * If we already have a non-NULL range pointer, check its end coordinate instead. * If it matches, close the *last* URI range we inserted on the new row, and free/remove the range from the old row. * When line breaking, we only need to check if the *last* URI range is unclosed.
2021-05-22 20:29:10 +02:00
struct row_uri_range new_range = {
.start = new_col_idx,
.end = -1,
.id = range->id,
grid: reflow: URI range start: take over ownership of URI string Instead of strdup:ing the URI, take over ownership. This is ok since the old URI range will be free:d anyway.
2021-05-28 18:19:21 +02:00
.uri = range->uri,
grid: reflow: uri-ranges: avoid looping URI ranges when reflowing Since we know the following: * URI ranges are sorted * URI coordinates are unique * URI ranges don’t cross rows We can optimize URI range reflowing by: * Checking if the *first* URI range’s start coordinate is on the current column. If so, keep a pointer to it. * Use this pointer as source when instantiating the reflowed URI range * If we already have a non-NULL range pointer, check its end coordinate instead. * If it matches, close the *last* URI range we inserted on the new row, and free/remove the range from the old row. * When line breaking, we only need to check if the *last* URI range is unclosed.
2021-05-22 20:29:10 +02:00
};
grid: reflow: URI range start: take over ownership of URI string Instead of strdup:ing the URI, take over ownership. This is ok since the old URI range will be free:d anyway.
2021-05-28 18:19:21 +02:00
range->uri = NULL;
grid: reflow: uri-ranges: avoid looping URI ranges when reflowing Since we know the following: * URI ranges are sorted * URI coordinates are unique * URI ranges don’t cross rows We can optimize URI range reflowing by: * Checking if the *first* URI range’s start coordinate is on the current column. If so, keep a pointer to it. * Use this pointer as source when instantiating the reflowed URI range * If we already have a non-NULL range pointer, check its end coordinate instead. * If it matches, close the *last* URI range we inserted on the new row, and free/remove the range from the old row. * When line breaking, we only need to check if the *last* URI range is unclosed.
2021-05-22 20:29:10 +02:00
grid_row_add_uri_range(new_row, new_range);
}
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
grid: reflow: uri-ranges: avoid looping URI ranges when reflowing Since we know the following: * URI ranges are sorted * URI coordinates are unique * URI ranges don’t cross rows We can optimize URI range reflowing by: * Checking if the *first* URI range’s start coordinate is on the current column. If so, keep a pointer to it. * Use this pointer as source when instantiating the reflowed URI range * If we already have a non-NULL range pointer, check its end coordinate instead. * If it matches, close the *last* URI range we inserted on the new row, and free/remove the range from the old row. * When line breaking, we only need to check if the *last* URI range is unclosed.
2021-05-22 20:29:10 +02:00
static void
reflow_uri_range_end(struct row_uri_range *range, struct row *new_row,
int new_col_idx)
{
xassert(tll_length(new_row->extra->uri_ranges) > 0);
struct row_uri_range *new_range = &tll_back(new_row->extra->uri_ranges);
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
grid: reflow: uri-ranges: avoid looping URI ranges when reflowing Since we know the following: * URI ranges are sorted * URI coordinates are unique * URI ranges don’t cross rows We can optimize URI range reflowing by: * Checking if the *first* URI range’s start coordinate is on the current column. If so, keep a pointer to it. * Use this pointer as source when instantiating the reflowed URI range * If we already have a non-NULL range pointer, check its end coordinate instead. * If it matches, close the *last* URI range we inserted on the new row, and free/remove the range from the old row. * When line breaking, we only need to check if the *last* URI range is unclosed.
2021-05-22 20:29:10 +02:00
xassert(new_range->id == range->id);
xassert(new_range->end < 0);
new_range->end = new_col_idx;
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
}
static struct row *
_line_wrap(struct grid *old_grid, struct row **new_grid, struct row *row,
int *row_idx, int *col_idx, int row_count, int col_count)
{
*col_idx = 0;
*row_idx = (*row_idx + 1) & (row_count - 1);
struct row *new_row = new_grid[*row_idx];
if (new_row == NULL) {
/* Scrollback not yet full, allocate a completely new row */
grid: reflow: don’t initialize newly allocated rows We’re going to write to it immediately anyway. In most cases, *all* newly allocated, and zero-initialized, cells are overwritten. So let’s skip the zero-initialization of the new cells. There are two cases where we need to explicitly clear cells now: * When inserting a hard line break - erase the remaining cells * When done, the *last* row may not have been completely written - erase the remaining cells
2021-05-15 15:15:32 +02:00
new_row = grid_row_alloc(col_count, false);
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
new_grid[*row_idx] = new_row;
} else {
/* Scrollback is full, need to re-use a row */
grid_row_reset_extra(new_row);
new_row->linebreak = false;
tll_foreach(old_grid->sixel_images, it) {
if (it->item.pos.row == *row_idx) {
sixel_destroy(&it->item);
tll_remove(old_grid->sixel_images, it);
}
}
}
if (row->extra == NULL)
return new_row;
/*
* URI ranges are per row. Thus, we need to ‘close’ the still-open
* ranges on the previous row, and re-open them on the
* next/current row.
*/
grid: reflow: uri-ranges: avoid looping URI ranges when reflowing Since we know the following: * URI ranges are sorted * URI coordinates are unique * URI ranges don’t cross rows We can optimize URI range reflowing by: * Checking if the *first* URI range’s start coordinate is on the current column. If so, keep a pointer to it. * Use this pointer as source when instantiating the reflowed URI range * If we already have a non-NULL range pointer, check its end coordinate instead. * If it matches, close the *last* URI range we inserted on the new row, and free/remove the range from the old row. * When line breaking, we only need to check if the *last* URI range is unclosed.
2021-05-22 20:29:10 +02:00
if (tll_length(row->extra->uri_ranges) > 0) {
struct row_uri_range *range = &tll_back(row->extra->uri_ranges);
if (range->end < 0) {
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
grid: reflow: uri-ranges: avoid looping URI ranges when reflowing Since we know the following: * URI ranges are sorted * URI coordinates are unique * URI ranges don’t cross rows We can optimize URI range reflowing by: * Checking if the *first* URI range’s start coordinate is on the current column. If so, keep a pointer to it. * Use this pointer as source when instantiating the reflowed URI range * If we already have a non-NULL range pointer, check its end coordinate instead. * If it matches, close the *last* URI range we inserted on the new row, and free/remove the range from the old row. * When line breaking, we only need to check if the *last* URI range is unclosed.
2021-05-22 20:29:10 +02:00
/* Terminate URI range on the previous row */
range->end = col_count - 1;
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
grid: reflow: uri-ranges: avoid looping URI ranges when reflowing Since we know the following: * URI ranges are sorted * URI coordinates are unique * URI ranges don’t cross rows We can optimize URI range reflowing by: * Checking if the *first* URI range’s start coordinate is on the current column. If so, keep a pointer to it. * Use this pointer as source when instantiating the reflowed URI range * If we already have a non-NULL range pointer, check its end coordinate instead. * If it matches, close the *last* URI range we inserted on the new row, and free/remove the range from the old row. * When line breaking, we only need to check if the *last* URI range is unclosed.
2021-05-22 20:29:10 +02:00
/* Open a new range on the new/current row */
struct row_uri_range new_range = {
.start = 0,
.end = -1,
.id = range->id,
.uri = xstrdup(range->uri),
};
grid_row_add_uri_range(new_row, new_range);
}
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
}
return new_row;
}
grid: reflow: qsort_r() is not portable Replace with qsort() + global variable. Not thread safe!
2021-05-15 13:37:46 +02:00
static struct {
grid: take scrollback start into account when sorting the tracking points array The row numbers in the tracking points are in absolute numbers. However, when we walk the old grid, we do so starting in the beginning of the scrollback history. We must ensure the tracking points are sorted such that the *first* one we see is the “oldest” one. I.e. the one furthest back in the scrollback history.
2021-05-15 12:54:59 +02:00
int scrollback_start;
int rows;
grid: reflow: qsort_r() is not portable Replace with qsort() + global variable. Not thread safe!
2021-05-15 13:37:46 +02:00
} tp_cmp_ctx;
grid: take scrollback start into account when sorting the tracking points array The row numbers in the tracking points are in absolute numbers. However, when we walk the old grid, we do so starting in the beginning of the scrollback history. We must ensure the tracking points are sorted such that the *first* one we see is the “oldest” one. I.e. the one furthest back in the scrollback history.
2021-05-15 12:54:59 +02:00
grid: reflow: use a sorted array for tracking points Instead of iterating a linked list of tracking points, for *each and every* cell in the old grid, use a sorted array. This allows us to step through the array of tracking points as we walk the old grid; each time we match a tracking point, we move to the next one. This means we only have to check a single tracking point for each cell.
2021-05-15 11:40:39 +02:00
static int
grid: reflow: qsort_r() is not portable Replace with qsort() + global variable. Not thread safe!
2021-05-15 13:37:46 +02:00
tp_cmp(const void *_a, const void *_b)
grid: reflow: use a sorted array for tracking points Instead of iterating a linked list of tracking points, for *each and every* cell in the old grid, use a sorted array. This allows us to step through the array of tracking points as we walk the old grid; each time we match a tracking point, we move to the next one. This means we only have to check a single tracking point for each cell.
2021-05-15 11:40:39 +02:00
{
const struct coord *a = *(const struct coord **)_a;
const struct coord *b = *(const struct coord **)_b;
grid: take scrollback start into account when sorting the tracking points array The row numbers in the tracking points are in absolute numbers. However, when we walk the old grid, we do so starting in the beginning of the scrollback history. We must ensure the tracking points are sorted such that the *first* one we see is the “oldest” one. I.e. the one furthest back in the scrollback history.
2021-05-15 12:54:59 +02:00
grid: reflow: qsort_r() is not portable Replace with qsort() + global variable. Not thread safe!
2021-05-15 13:37:46 +02:00
int scrollback_start = tp_cmp_ctx.scrollback_start;
int num_rows = tp_cmp_ctx.rows;
int a_row = (a->row - scrollback_start + num_rows) & (num_rows - 1);
int b_row = (b->row - scrollback_start + num_rows) & (num_rows - 1);
grid: reflow: use a sorted array for tracking points Instead of iterating a linked list of tracking points, for *each and every* cell in the old grid, use a sorted array. This allows us to step through the array of tracking points as we walk the old grid; each time we match a tracking point, we move to the next one. This means we only have to check a single tracking point for each cell.
2021-05-15 11:40:39 +02:00
grid: take scrollback start into account when sorting the tracking points array The row numbers in the tracking points are in absolute numbers. However, when we walk the old grid, we do so starting in the beginning of the scrollback history. We must ensure the tracking points are sorted such that the *first* one we see is the “oldest” one. I.e. the one furthest back in the scrollback history.
2021-05-15 12:54:59 +02:00
xassert(a_row >= 0);
grid: reflow: qsort_r() is not portable Replace with qsort() + global variable. Not thread safe!
2021-05-15 13:37:46 +02:00
xassert(a_row < num_rows || num_rows == 0);
grid: take scrollback start into account when sorting the tracking points array The row numbers in the tracking points are in absolute numbers. However, when we walk the old grid, we do so starting in the beginning of the scrollback history. We must ensure the tracking points are sorted such that the *first* one we see is the “oldest” one. I.e. the one furthest back in the scrollback history.
2021-05-15 12:54:59 +02:00
xassert(b_row >= 0);
grid: reflow: qsort_r() is not portable Replace with qsort() + global variable. Not thread safe!
2021-05-15 13:37:46 +02:00
xassert(b_row < num_rows || num_rows == 0);
grid: take scrollback start into account when sorting the tracking points array The row numbers in the tracking points are in absolute numbers. However, when we walk the old grid, we do so starting in the beginning of the scrollback history. We must ensure the tracking points are sorted such that the *first* one we see is the “oldest” one. I.e. the one furthest back in the scrollback history.
2021-05-15 12:54:59 +02:00
if (a_row < b_row)
grid: reflow: use a sorted array for tracking points Instead of iterating a linked list of tracking points, for *each and every* cell in the old grid, use a sorted array. This allows us to step through the array of tracking points as we walk the old grid; each time we match a tracking point, we move to the next one. This means we only have to check a single tracking point for each cell.
2021-05-15 11:40:39 +02:00
return -1;
grid: take scrollback start into account when sorting the tracking points array The row numbers in the tracking points are in absolute numbers. However, when we walk the old grid, we do so starting in the beginning of the scrollback history. We must ensure the tracking points are sorted such that the *first* one we see is the “oldest” one. I.e. the one furthest back in the scrollback history.
2021-05-15 12:54:59 +02:00
if (a_row > b_row)
grid: reflow: use a sorted array for tracking points Instead of iterating a linked list of tracking points, for *each and every* cell in the old grid, use a sorted array. This allows us to step through the array of tracking points as we walk the old grid; each time we match a tracking point, we move to the next one. This means we only have to check a single tracking point for each cell.
2021-05-15 11:40:39 +02:00
return 1;
grid: take scrollback start into account when sorting the tracking points array The row numbers in the tracking points are in absolute numbers. However, when we walk the old grid, we do so starting in the beginning of the scrollback history. We must ensure the tracking points are sorted such that the *first* one we see is the “oldest” one. I.e. the one furthest back in the scrollback history.
2021-05-15 12:54:59 +02:00
xassert(a_row == b_row);
grid: reflow: use a sorted array for tracking points Instead of iterating a linked list of tracking points, for *each and every* cell in the old grid, use a sorted array. This allows us to step through the array of tracking points as we walk the old grid; each time we match a tracking point, we move to the next one. This means we only have to check a single tracking point for each cell.
2021-05-15 11:40:39 +02:00
if (a->col < b->col)
return -1;
if (a->col > b->col)
return 1;
xassert(a->col == b->col);
return 0;
}
resize: don’t reflow text on alt screen Alt screen applications normally reflow/readjust themselves on a window resize. When we do it too, the result is graphical glitches/flashes since our re-flowed text is rendered in one frame, and the application re-flowed text soon thereafter. We can’t avoid rendering some kind of re-flowed frame, since we don’t know when, or even if, the application will update itself. To avoid glitches, we need to render, as closely as possible, what the application itself will render shortly. This is actually pretty simple; we just need to copy the visible content over from the old grid to the new grid. We don’t bother with text re-flow, but simply truncate long lines. To simplify things, we simply cancel any active selection (since often times, it will be corrupted anyway when the application redraws itself). Since we’re not reflowing text, there’s no need to translate e.g. the cursor position - we just keep the current position (but bounded to the new dimensions). Fun thing: ‘less’ gets corrupted if we don’t leave the cursor at the (new) bottom row. To handle this, we check if the cursor (before resize) is at the bottom row, and if so, we move it to the new bottom row. Closes #221
2020-11-24 19:00:57 +01:00
void
grid_resize_and_reflow(
struct grid *grid, int new_rows, int new_cols,
int old_screen_rows, int new_screen_rows,
size_t tracking_points_count,
composed: store compose chains in a binary search tree The previous implementation stored compose chains in a dynamically allocated array. Adding a chain was easy: resize the array and append the new chain at the end. Looking up a compose chain given a compose chain key/index was also easy: just index into the array. However, searching for a pre-existing chain given a codepoint sequence was very slow. Since the array wasn’t sorted, we typically had to scan through the entire array, just to realize that there is no pre-existing chain, and that we need to add a new one. Since this happens for *each* codepoint in a grapheme cluster, things quickly became really slow. Things were ok:ish as long as the compose chain struct was small, as that made it possible to hold all the chains in the cache. Once the number of chains reached a certain point, or when we were forced to bump maximum number of allowed codepoints in a chain, we started thrashing the cache and things got much much worse. So what can we do? We can’t sort the array, because a) that would invalidate all existing chain keys in the grid (and iterating the entire scrollback and updating compose keys is *not* an option). b) inserting a chain becomes slow as we need to first find _where_ to insert it, and then memmove() the rest of the array. This patch uses a binary search tree to store the chains instead of a simple array. The tree is sorted on a “key”, which is the XOR of all codepoints, truncated to the CELL_COMB_CHARS_HI-CELL_COMB_CHARS_LO range. The grid now stores CELL_COMB_CHARS_LO+key, instead of CELL_COMB_CHARS_LO+index. Since the key is truncated, collisions may occur. This is handled by incrementing the key by 1. Lookup is of course slower than before, O(log n) instead of O(1). Insertion is slightly slower as well: technically it’s O(log n) instead of O(1). However, we also need to take into account the re-allocating the array will occasionally force a full copy of the array when it cannot simply be growed. But finding a pre-existing chain is now *much* faster: O(log n) instead of O(n). In most cases, the first lookup will either succeed (return a true match), or fail (return NULL). However, since key collisions are possible, it may also return false matches. This means we need to verify the contents of the chain before deciding to use it instead of inserting a new chain. But remember that this comparison was being done for each and every chain in the previous implementation. With lookups being much faster, and in particular, no longer requiring us to check the chain contents for every singlec chain, we can now use a dynamically allocated ‘chars’ array in the chain. This was previously a hardcoded array of 10 chars. Using a dynamic allocated array means looking in the array is slower, since we now need two loads: one to load the pointer, and a second to load _from_ the pointer. As a result, the base size of a compose chain (i.e. an “empty” chain) has now been reduced from 48 bytes to 32. A chain with two codepoints is 40 bytes. This means we have up to 4 codepoints while still using less, or the same amount, of memory as before. Furthermore, the Unicode random test (i.e. write random “unicode” chars) is now **faster** than current master (i.e. before text-shaping support was added), **with** test-shaping enabled. With text-shaping disabled, we’re _even_ faster.
2021-06-24 13:17:07 +02:00
struct coord *const _tracking_points[static tracking_points_count])
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
{
grid: add compile-time define to enable timing of the reflow operation
2021-05-11 17:43:17 +02:00
#if defined(TIME_REFLOW) && TIME_REFLOW
struct timeval start;
gettimeofday(&start, NULL);
#endif
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
struct row *const *old_grid = grid->rows;
const int old_rows = grid->num_rows;
const int old_cols = grid->num_cols;
grid: reflow: retain scrollback position Closes #142
2020-09-24 18:35:40 +02:00
/* Is viewpoint tracking current grid offset? */
const bool view_follows = grid->view == grid->offset;
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
int new_col_idx = 0;
int new_row_idx = 0;
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
struct row **new_grid = xcalloc(new_rows, sizeof(new_grid[0]));
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
struct row *new_row = new_grid[new_row_idx];
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(new_row == NULL);
grid: reflow: don’t initialize newly allocated rows We’re going to write to it immediately anyway. In most cases, *all* newly allocated, and zero-initialized, cells are overwritten. So let’s skip the zero-initialization of the new cells. There are two cases where we need to explicitly clear cells now: * When inserting a hard line break - erase the remaining cells * When done, the *last* row may not have been completely written - erase the remaining cells
2021-05-15 15:15:32 +02:00
new_row = grid_row_alloc(new_cols, false);
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
new_grid[new_row_idx] = new_row;
/* Start at the beginning of the old grid's scrollback. That is,
* at the output that is *oldest* */
int offset = grid->offset + old_screen_rows;
grid: reflow: re-insert sixels *after* new grid offset has been set Also make sure to destroy sixels that are too big to fit in the scrollback. Fixes issues with the sixel list not being sorted correctly.
2020-10-03 23:00:34 +02:00
tll(struct sixel) untranslated_sixels = tll_init();
reflow: ensure sixels are correctly sorted when re-inserted And make sure to remove re-inserted sixels that has wrapped around the scrollback (this may happen when the window size decreases).
2020-06-29 21:59:40 +02:00
tll_foreach(grid->sixel_images, it)
grid: reflow: re-insert sixels *after* new grid offset has been set Also make sure to destroy sixels that are too big to fit in the scrollback. Fixes issues with the sixel list not being sorted correctly.
2020-10-03 23:00:34 +02:00
tll_push_back(untranslated_sixels, it->item);
reflow: ensure sixels are correctly sorted when re-inserted And make sure to remove re-inserted sixels that has wrapped around the scrollback (this may happen when the window size decreases).
2020-06-29 21:59:40 +02:00
tll_free(grid->sixel_images);
sixel: improve handling of images when reflowing the grids Update the sixels' 'row' attribute when re-flowing a grid, to ensure it is rendered at the correct place. This should work in most cases, but will break when the cell size has changed (e.g. font size increase/decrease, or a DPI change). This patch also moves the sixel image list from the terminal struct into the grid struct. The sixels are per-grid after all.
2020-03-13 18:44:23 +01:00
grid: grid_reflow() now translates cursor coordinates
2020-04-16 19:38:30 +02:00
/* Turn cursor coordinates into grid absolute coordinates */
struct coord cursor = grid->cursor.point;
cursor.row += grid->offset;
cursor.row &= old_rows - 1;
struct coord saved_cursor = grid->saved_cursor.point;
saved_cursor.row += grid->offset;
saved_cursor.row &= old_rows - 1;
grid: reflow: use a sorted array for tracking points Instead of iterating a linked list of tracking points, for *each and every* cell in the old grid, use a sorted array. This allows us to step through the array of tracking points as we walk the old grid; each time we match a tracking point, we move to the next one. This means we only have to check a single tracking point for each cell.
2021-05-15 11:40:39 +02:00
size_t tp_count =
tracking_points_count +
1 + /* cursor */
1 + /* saved cursor */
!view_follows + /* viewport */
1; /* terminator */
struct coord *tracking_points[tp_count];
memcpy(tracking_points, _tracking_points, tracking_points_count * sizeof(_tracking_points[0]));
tracking_points[tracking_points_count] = &cursor;
tracking_points[tracking_points_count + 1] = &saved_cursor;
grid: reflow: generalize cursor coordinate translation Define a list of "tracking points" - coordinates that should be translated while reflowing. Add the cursor coordinates to this list. When a coordinate have been translated, it is removed from the list. This means we don't have to create a copy of the 'cursor' coordinate struct.
2020-04-17 21:00:37 +02:00
grid: reflow: retain scrollback position Closes #142
2020-09-24 18:35:40 +02:00
struct coord viewport = {0, grid->view};
if (!view_follows)
grid: reflow: use a sorted array for tracking points Instead of iterating a linked list of tracking points, for *each and every* cell in the old grid, use a sorted array. This allows us to step through the array of tracking points as we walk the old grid; each time we match a tracking point, we move to the next one. This means we only have to check a single tracking point for each cell.
2021-05-15 11:40:39 +02:00
tracking_points[tracking_points_count + 2] = &viewport;
grid: reflow: qsort_r() is not portable Replace with qsort() + global variable. Not thread safe!
2021-05-15 13:37:46 +02:00
/* Not thread safe! */
tp_cmp_ctx.scrollback_start = offset;
tp_cmp_ctx.rows = old_rows;
qsort(
tracking_points, tp_count - 1, sizeof(tracking_points[0]), &tp_cmp);
grid: reflow: retain scrollback position Closes #142
2020-09-24 18:35:40 +02:00
grid: reflow: use a sorted array for tracking points Instead of iterating a linked list of tracking points, for *each and every* cell in the old grid, use a sorted array. This allows us to step through the array of tracking points as we walk the old grid; each time we match a tracking point, we move to the next one. This means we only have to check a single tracking point for each cell.
2021-05-15 11:40:39 +02:00
/* NULL terminate */
struct coord terminator = {-1, -1};
tracking_points[tp_count - 1] = &terminator;
struct coord **next_tp = &tracking_points[0];
grid: reflow: caller may now pass a list of coordinates that should be translated
2020-04-17 21:04:32 +02:00
grid: take scrollback start into account when sorting the tracking points array The row numbers in the tracking points are in absolute numbers. However, when we walk the old grid, we do so starting in the beginning of the scrollback history. We must ensure the tracking points are sorted such that the *first* one we see is the “oldest” one. I.e. the one furthest back in the scrollback history.
2021-05-15 12:54:59 +02:00
LOG_DBG("scrollback-start=%d", offset);
for (size_t i = 0; i < tp_count - 1; i++) {
LOG_DBG("TP #%zu: row=%d, col=%d",
i, tracking_points[i]->row, tracking_points[i]->col);
}
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
/*
* Walk the old grid
*/
for (int r = 0; r < old_rows; r++) {
grid: grid_reflow() now translates cursor coordinates
2020-04-16 19:38:30 +02:00
const size_t old_row_idx = (offset + r) & (old_rows - 1);
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
/* Unallocated (empty) rows we can simply skip */
grid: grid_reflow() now translates cursor coordinates
2020-04-16 19:38:30 +02:00
const struct row *old_row = old_grid[old_row_idx];
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
if (old_row == NULL)
continue;
reflow: ensure sixels are correctly sorted when re-inserted And make sure to remove re-inserted sixels that has wrapped around the scrollback (this may happen when the window size decreases).
2020-06-29 21:59:40 +02:00
/* Map sixels on current "old" row to current "new row" */
grid: reflow: re-insert sixels *after* new grid offset has been set Also make sure to destroy sixels that are too big to fit in the scrollback. Fixes issues with the sixel list not being sorted correctly.
2020-10-03 23:00:34 +02:00
tll_foreach(untranslated_sixels, it) {
reflow: ensure sixels are correctly sorted when re-inserted And make sure to remove re-inserted sixels that has wrapped around the scrollback (this may happen when the window size decreases).
2020-06-29 21:59:40 +02:00
if (it->item.pos.row != old_row_idx)
continue;
struct sixel sixel = it->item;
sixel.pos.row = new_row_idx;
sixel: implement reflow Move sixel reflow from grid_reflow() to sixel_reflow(). This lets us use internal sixel functions to update the sixels. Note that grid_reflow() still needs to remap the sixelss coordinates.
2020-10-04 13:12:44 +02:00
tll_push_back(grid->sixel_images, sixel);
grid: reflow: re-insert sixels *after* new grid offset has been set Also make sure to destroy sixels that are too big to fit in the scrollback. Fixes issues with the sixel list not being sorted correctly.
2020-10-03 23:00:34 +02:00
tll_remove(untranslated_sixels, it);
sixel: improve handling of images when reflowing the grids Update the sixels' 'row' attribute when re-flowing a grid, to ensure it is rendered at the correct place. This should work in most cases, but will break when the cell size has changed (e.g. font size increase/decrease, or a DPI change). This patch also moves the sixel image list from the terminal struct into the grid struct. The sixels are per-grid after all.
2020-03-13 18:44:23 +01:00
}
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
#define line_wrap() \
new_row = _line_wrap( \
grid, new_grid, new_row, &new_row_idx, &new_col_idx, \
new_rows, new_cols)
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
/* Find last non-empty cell */
int col_count = 0;
grid: reflow: check the *entire* row for non-empty cells
2021-05-28 17:41:13 +02:00
for (int c = old_cols - 1; c >= 0; c--) {
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
const struct cell *cell = &old_row->cells[c];
if (!(cell->wc == 0 || cell->wc == CELL_SPACER)) {
col_count = c + 1;
break;
}
}
xassert(col_count >= 0 && col_count <= old_cols);
grid: reflow: avoid unnecessary if-statements before chunking a row
2021-05-26 12:27:12 +02:00
/* Do we have a (at least one) tracking point on this row */
struct coord *tp;
grid: reflow: when determining row end coord, check *last* tracking point
2021-05-28 17:41:47 +02:00
if (unlikely((*next_tp)->row == old_row_idx)) {
grid: reflow: avoid unnecessary if-statements before chunking a row
2021-05-26 12:27:12 +02:00
tp = *next_tp;
grid: reflow: when determining row end coord, check *last* tracking point
2021-05-28 17:41:47 +02:00
/* Find the *last* tracking point on this row */
struct coord *last_on_row = tp;
for (struct coord **iter = next_tp; (*iter)->row == old_row_idx; iter++)
last_on_row = *iter;
/* And make sure its end point is included in the col range */
xassert(last_on_row->row == old_row_idx);
col_count = max(col_count, last_on_row->col + 1);
grid: reflow: avoid unnecessary if-statements before chunking a row
2021-05-26 12:27:12 +02:00
} else
tp = NULL;
/* Does this row have any URIs? */
struct row_uri_range *range;
if (old_row->extra != NULL && tll_length(old_row->extra->uri_ranges) > 0) {
range = &tll_front(old_row->extra->uri_ranges);
grid: reflow: when determining row end coord, check *last* URI range
2021-05-28 17:42:09 +02:00
/* Make sure the *last* URI range's end point is included in the copy */
const struct row_uri_range *last_on_row =
&tll_back(old_row->extra->uri_ranges);
col_count = max(col_count, last_on_row->end + 1);
grid: reflow: avoid unnecessary if-statements before chunking a row
2021-05-26 12:27:12 +02:00
} else
range = NULL;
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
for (int start = 0, left = col_count; left > 0;) {
int end;
grid: set tp/uri break flags explicitly when we know them to be true
2021-05-25 19:31:38 +02:00
bool tp_break = false;
bool uri_break = false;
grid: reflow: comments
2021-05-25 19:40:10 +02:00
/*
* Set end-coordinate for this chunk, by finding the next
* point-of-interrest on this row.
*
* If there are no more tracking points, or URI ranges,
* the end-coordinate will be at the end of the row,
*/
grid: reflow: slightly simplified logic for end-coordinate calculation
2021-05-25 19:28:11 +02:00
if (range != NULL) {
grid: no need to keep the tp_col/uri_col variables around
2021-05-25 19:34:21 +02:00
int uri_col = (range->start >= start ? range->start : range->end) + 1;
grid: reflow: slightly simplified logic for end-coordinate calculation
2021-05-25 19:28:11 +02:00
if (tp != NULL) {
grid: no need to keep the tp_col/uri_col variables around
2021-05-25 19:34:21 +02:00
int tp_col = tp->col + 1;
grid: reflow: slightly simplified logic for end-coordinate calculation
2021-05-25 19:28:11 +02:00
end = min(tp_col, uri_col);
grid: set tp/uri break flags explicitly when we know them to be true
2021-05-25 19:31:38 +02:00
tp_break = end == tp_col;
uri_break = end == uri_col;
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
LOG_DBG("tp+uri break at %d (%d, %d)", end, tp_col, uri_col);
grid: set tp/uri break flags explicitly when we know them to be true
2021-05-25 19:31:38 +02:00
} else {
grid: reflow: slightly simplified logic for end-coordinate calculation
2021-05-25 19:28:11 +02:00
end = uri_col;
grid: set tp/uri break flags explicitly when we know them to be true
2021-05-25 19:31:38 +02:00
uri_break = true;
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
LOG_DBG("uri break at %d", end);
grid: set tp/uri break flags explicitly when we know them to be true
2021-05-25 19:31:38 +02:00
}
} else if (tp != NULL) {
grid: no need to keep the tp_col/uri_col variables around
2021-05-25 19:34:21 +02:00
end = tp->col + 1;
grid: set tp/uri break flags explicitly when we know them to be true
2021-05-25 19:31:38 +02:00
tp_break = true;
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
LOG_DBG("TP break at %d", end);
grid: set tp/uri break flags explicitly when we know them to be true
2021-05-25 19:31:38 +02:00
} else
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
end = col_count;
int cols = end - start;
xassert(cols > 0);
xassert(start + cols <= old_cols);
grid: reflow: comments
2021-05-25 19:40:10 +02:00
/*
* Copy the row chunk to the new grid. Note that there may
* be fewer cells left on the new row than what we have in
* the chunk. I.e. the chunk may have to be split up into
* multiple memcpy:ies.
*/
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
for (int count = cols, from = start; count > 0;) {
xassert(new_col_idx <= new_cols);
int new_row_cells_left = new_cols - new_col_idx;
grid: reflow: comments
2021-05-25 19:40:10 +02:00
/* Row full, emit newline and get a new, fresh, row */
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
if (new_row_cells_left <= 0) {
line_wrap();
new_row_cells_left = new_cols;
}
grid: reflow: comments
2021-05-25 19:40:10 +02:00
/* Number of cells we can copy */
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
int amount = min(count, new_row_cells_left);
xassert(amount > 0);
grid: reflow: comments
2021-05-25 19:40:10 +02:00
/*
* If we’re going to reach the end of the new row, we
* need to make sure we don’t end in the middle of a
* multi-column character.
*/
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
int spacers = 0;
if (new_col_idx + amount >= new_cols) {
/*
grid: reflow: comments
2021-05-25 19:40:10 +02:00
* While the cell *after* the last cell is a CELL_SPACER
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
*
* This means we have a multi-column character
* that doesn’t fit on the current row. We need to
* push it to the next row, and insert CELL_SPACER
* cells as padding.
*/
while (
unlikely(
amount > 1 &&
from + amount < old_cols &&
old_row->cells[from + amount].wc >= CELL_SPACER + 1))
{
amount--;
spacers++;
}
xassert(
amount == 1 ||
old_row->cells[from + amount - 1].wc <= CELL_SPACER + 1);
}
xassert(new_col_idx + amount <= new_cols);
xassert(from + amount <= old_cols);
memcpy(
&new_row->cells[new_col_idx], &old_row->cells[from],
amount * sizeof(struct cell));
count -= amount;
from += amount;
new_col_idx += amount;
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
xassert(new_col_idx <= new_cols);
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
if (unlikely(spacers > 0)) {
xassert(new_col_idx + spacers == new_cols);
grid: reflow: ‘amount’ has already been added to ‘from’
2021-06-02 19:30:01 +02:00
const struct cell *cell = &old_row->cells[from - 1];
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
for (int i = 0; i < spacers; i++, new_col_idx++) {
new_row->cells[new_col_idx].wc = CELL_SPACER;
new_row->cells[new_col_idx].attrs = cell->attrs;
}
}
}
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
xassert(new_col_idx > 0);
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
if (tp_break) {
do {
xassert(tp != NULL);
xassert(tp->row == old_row_idx);
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
xassert(tp->col == end - 1);
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
tp->row = new_row_idx;
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
tp->col = new_col_idx - 1;
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
next_tp++;
tp = *next_tp;
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
} while (tp->row == old_row_idx && tp->col == end - 1);
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
if (tp->row != old_row_idx)
tp = NULL;
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
LOG_DBG("next TP (tp=%p): %dx%d",
(void*)tp, (*next_tp)->row, (*next_tp)->col);
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
}
if (uri_break) {
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
if (range->start == end - 1)
reflow_uri_range_start(range, new_row, new_col_idx - 1);
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
if (range->end == end - 1) {
reflow_uri_range_end(range, new_row, new_col_idx - 1);
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
grid: reflow: rename _range -> range
2021-05-25 19:22:52 +02:00
xassert(&tll_front(old_row->extra->uri_ranges) == range);
grid_row_uri_range_destroy(range);
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
tll_pop_front(old_row->extra->uri_ranges);
grid: reflow: rename _range -> range
2021-05-25 19:22:52 +02:00
range = tll_length(old_row->extra->uri_ranges) > 0
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
? &tll_front(old_row->extra->uri_ranges)
: NULL;
}
}
left -= cols;
start += cols;
}
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
if (old_row->linebreak) {
grid: reflow: don’t initialize newly allocated rows We’re going to write to it immediately anyway. In most cases, *all* newly allocated, and zero-initialized, cells are overwritten. So let’s skip the zero-initialization of the new cells. There are two cases where we need to explicitly clear cells now: * When inserting a hard line break - erase the remaining cells * When done, the *last* row may not have been completely written - erase the remaining cells
2021-05-15 15:15:32 +02:00
/* Erase the remaining cells */
memset(&new_row->cells[new_col_idx], 0,
(new_cols - new_col_idx) * sizeof(new_row->cells[0]));
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
new_row->linebreak = true;
grid: reflow: turn line-wrapping code into a macro
2020-04-17 20:46:08 +02:00
line_wrap();
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
}
grid: reflow: turn line-wrapping code into a macro
2020-04-17 20:46:08 +02:00
grid: reflow: free old rows as soon as we’re done with them This reduces the memory cost of reflowing text, as we no longer needs to hold both the old and the new grid, in their entirety, in memory at the same time.
2021-05-16 10:11:41 +02:00
grid_row_free(old_grid[old_row_idx]);
grid->rows[old_row_idx] = NULL;
grid: reflow: turn line-wrapping code into a macro
2020-04-17 20:46:08 +02:00
#undef line_wrap
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
}
grid: reflow: don’t initialize newly allocated rows We’re going to write to it immediately anyway. In most cases, *all* newly allocated, and zero-initialized, cells are overwritten. So let’s skip the zero-initialization of the new cells. There are two cases where we need to explicitly clear cells now: * When inserting a hard line break - erase the remaining cells * When done, the *last* row may not have been completely written - erase the remaining cells
2021-05-15 15:15:32 +02:00
/* Erase the remaining cells */
memset(&new_row->cells[new_col_idx], 0,
(new_cols - new_col_idx) * sizeof(new_row->cells[0]));
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
for (struct coord **tp = next_tp; *tp != &terminator; tp++) {
grid: reflow: debug logging
2021-05-28 17:42:25 +02:00
LOG_DBG("TP: row=%d, col=%d (old cols: %d, new cols: %d)",
(*tp)->row, (*tp)->col, old_cols, new_cols);
grid: reflow: memcpy() chunks of cells, instead of single cell-by-cell Instead of walking the old grid cell-by-cell, and checking for tracking points, OSC-8 URIs etc on each cell, memcpy() sequences of cells. For each row, find the end column, by scanning backward, looking for the first non-empty cell. Chunk the row based on tracking point coordinates. If there aren’t any tracking coordinates, or OSC-8 URIs on the current row, the entire row is copied in one go. The chunk of cells is copied to the new grid. We may have to split it up into multiple copies, since not all cells may fit on the current “new” row. Care must also be taken to not line break in the middle of a multi-column character.
2021-05-23 21:15:06 +02:00
}
grid: reflow: use a sorted array for tracking points Instead of iterating a linked list of tracking points, for *each and every* cell in the old grid, use a sorted array. This allows us to step through the array of tracking points as we walk the old grid; each time we match a tracking point, we move to the next one. This means we only have to check a single tracking point for each cell.
2021-05-15 11:40:39 +02:00
xassert(old_rows == 0 || *next_tp == &terminator);
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
#if defined(_DEBUG)
/* Verify all URI ranges have been “closed” */
for (int r = 0; r < new_rows; r++) {
const struct row *row = new_grid[r];
if (row == NULL)
continue;
if (row->extra == NULL)
continue;
tll_foreach(row->extra->uri_ranges, it)
xassert(it->item.end >= 0);
}
grid: reflow: free old rows as soon as we’re done with them This reduces the memory cost of reflowing text, as we no longer needs to hold both the old and the new grid, in their entirety, in memory at the same time.
2021-05-16 10:11:41 +02:00
/* Verify all old rows have been free:d */
for (int i = 0; i < old_rows; i++)
xassert(grid->rows[i] == NULL);
grid: reflow: translate URI ranges URI ranges are per row. Translate by detecting URI range start/end coordinates, and opening and closing a corresponding URI range on the new grid. We need to take care when line-wrapping the new grid; here we need to manually close the still-open URI ranges (on the new grid), and re-opening them on the next row.
2021-02-14 20:34:49 +01:00
#endif
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
/* Set offset such that the last reflowed row is at the bottom */
grid->offset = new_row_idx - new_screen_rows + 1;
while (grid->offset < 0)
grid->offset += new_rows;
while (new_grid[grid->offset] == NULL)
grid->offset = (grid->offset + 1) & (new_rows - 1);
grid: reflow: retain scrollback position Closes #142
2020-09-24 18:35:40 +02:00
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
/* Ensure all visible rows have been allocated */
for (int r = 0; r < new_screen_rows; r++) {
int idx = (grid->offset + r) & (new_rows - 1);
if (new_grid[idx] == NULL)
new_grid[idx] = grid_row_alloc(new_cols, true);
}
grid: reflow: handle viewport being too far down when enlarging the window If the viewport is close to the bottom, but not *at* the bottom, and we’re enlarging the window, the translated viewport will be too far down.
2020-09-24 18:48:41 +02:00
grid->view = view_follows ? grid->offset : viewport.row;
/* If enlarging the window, the old viewport may be too far down,
* with unallocated rows. Make sure this cannot happen */
while (true) {
int idx = (grid->view + new_screen_rows - 1) & (new_rows - 1);
if (new_grid[idx] != NULL)
break;
grid->view--;
if (grid->view < 0)
grid->view += new_rows;
}
for (size_t r = 0; r < new_screen_rows; r++) {
grid: reflow: fix release build; ‘idx’ is only used in an assert()
2020-09-24 18:53:05 +02:00
int UNUSED idx = (grid->view + r) & (new_rows - 1);
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(new_grid[idx] != NULL);
grid: reflow: handle viewport being too far down when enlarging the window If the viewport is close to the bottom, but not *at* the bottom, and we’re enlarging the window, the translated viewport will be too far down.
2020-09-24 18:48:41 +02:00
}
grid: reflow: free old rows as soon as we’re done with them This reduces the memory cost of reflowing text, as we no longer needs to hold both the old and the new grid, in their entirety, in memory at the same time.
2021-05-16 10:11:41 +02:00
/* Free old grid (rows already free:d) */
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
free(grid->rows);
grid->rows = new_grid;
grid->num_rows = new_rows;
grid->num_cols = new_cols;
grid: grid_reflow() now translates cursor coordinates
2020-04-16 19:38:30 +02:00
/* Convert absolute coordinates to screen relative */
grid: reflow: generalize cursor coordinate translation Define a list of "tracking points" - coordinates that should be translated while reflowing. Add the cursor coordinates to this list. When a coordinate have been translated, it is removed from the list. This means we don't have to create a copy of the 'cursor' coordinate struct.
2020-04-17 21:00:37 +02:00
cursor.row -= grid->offset;
while (cursor.row < 0)
cursor.row += grid->num_rows;
grid: reflow: make sure cursor is within the visible screen area Even though we translate the cursor position from the old grid coordinates to the new, the cursor may _still_ end up outside the visible area. Make sure it doesn’t.
2020-09-09 18:40:06 +02:00
cursor.row = min(cursor.row, new_screen_rows - 1);
resize: don’t reflow text on alt screen Alt screen applications normally reflow/readjust themselves on a window resize. When we do it too, the result is graphical glitches/flashes since our re-flowed text is rendered in one frame, and the application re-flowed text soon thereafter. We can’t avoid rendering some kind of re-flowed frame, since we don’t know when, or even if, the application will update itself. To avoid glitches, we need to render, as closely as possible, what the application itself will render shortly. This is actually pretty simple; we just need to copy the visible content over from the old grid to the new grid. We don’t bother with text re-flow, but simply truncate long lines. To simplify things, we simply cancel any active selection (since often times, it will be corrupted anyway when the application redraws itself). Since we’re not reflowing text, there’s no need to translate e.g. the cursor position - we just keep the current position (but bounded to the new dimensions). Fun thing: ‘less’ gets corrupted if we don’t leave the cursor at the (new) bottom row. To handle this, we check if the cursor (before resize) is at the bottom row, and if so, we move it to the new bottom row. Closes #221
2020-11-24 19:00:57 +01:00
cursor.col = min(cursor.col, new_cols - 1);
grid: grid_reflow() now translates cursor coordinates
2020-04-16 19:38:30 +02:00
grid: reflow: generalize cursor coordinate translation Define a list of "tracking points" - coordinates that should be translated while reflowing. Add the cursor coordinates to this list. When a coordinate have been translated, it is removed from the list. This means we don't have to create a copy of the 'cursor' coordinate struct.
2020-04-17 21:00:37 +02:00
saved_cursor.row -= grid->offset;
while (saved_cursor.row < 0)
saved_cursor.row += grid->num_rows;
grid: reflow: make sure cursor is within the visible screen area Even though we translate the cursor position from the old grid coordinates to the new, the cursor may _still_ end up outside the visible area. Make sure it doesn’t.
2020-09-09 18:40:06 +02:00
saved_cursor.row = min(saved_cursor.row, new_screen_rows - 1);
resize: don’t reflow text on alt screen Alt screen applications normally reflow/readjust themselves on a window resize. When we do it too, the result is graphical glitches/flashes since our re-flowed text is rendered in one frame, and the application re-flowed text soon thereafter. We can’t avoid rendering some kind of re-flowed frame, since we don’t know when, or even if, the application will update itself. To avoid glitches, we need to render, as closely as possible, what the application itself will render shortly. This is actually pretty simple; we just need to copy the visible content over from the old grid to the new grid. We don’t bother with text re-flow, but simply truncate long lines. To simplify things, we simply cancel any active selection (since often times, it will be corrupted anyway when the application redraws itself). Since we’re not reflowing text, there’s no need to translate e.g. the cursor position - we just keep the current position (but bounded to the new dimensions). Fun thing: ‘less’ gets corrupted if we don’t leave the cursor at the (new) bottom row. To handle this, we check if the cursor (before resize) is at the bottom row, and if so, we move it to the new bottom row. Closes #221
2020-11-24 19:00:57 +01:00
saved_cursor.col = min(saved_cursor.col, new_cols - 1);
grid: grid_reflow() now translates cursor coordinates
2020-04-16 19:38:30 +02:00
resize: don’t reflow text on alt screen Alt screen applications normally reflow/readjust themselves on a window resize. When we do it too, the result is graphical glitches/flashes since our re-flowed text is rendered in one frame, and the application re-flowed text soon thereafter. We can’t avoid rendering some kind of re-flowed frame, since we don’t know when, or even if, the application will update itself. To avoid glitches, we need to render, as closely as possible, what the application itself will render shortly. This is actually pretty simple; we just need to copy the visible content over from the old grid to the new grid. We don’t bother with text re-flow, but simply truncate long lines. To simplify things, we simply cancel any active selection (since often times, it will be corrupted anyway when the application redraws itself). Since we’re not reflowing text, there’s no need to translate e.g. the cursor position - we just keep the current position (but bounded to the new dimensions). Fun thing: ‘less’ gets corrupted if we don’t leave the cursor at the (new) bottom row. To handle this, we check if the cursor (before resize) is at the bottom row, and if so, we move it to the new bottom row. Closes #221
2020-11-24 19:00:57 +01:00
grid->cur_row = new_grid[(grid->offset + cursor.row) & (new_rows - 1)];
grid: reflow: generalize cursor coordinate translation Define a list of "tracking points" - coordinates that should be translated while reflowing. Add the cursor coordinates to this list. When a coordinate have been translated, it is removed from the list. This means we don't have to create a copy of the 'cursor' coordinate struct.
2020-04-17 21:00:37 +02:00
grid->cursor.point = cursor;
grid->saved_cursor.point = saved_cursor;
grid: grid_reflow() now translates cursor coordinates
2020-04-16 19:38:30 +02:00
grid->cursor.lcf = false;
grid->saved_cursor.lcf = false;
reflow: ensure sixels are correctly sorted when re-inserted And make sure to remove re-inserted sixels that has wrapped around the scrollback (this may happen when the window size decreases).
2020-06-29 21:59:40 +02:00
/* Free sixels we failed to "map" to the new grid */
grid: reflow: re-insert sixels *after* new grid offset has been set Also make sure to destroy sixels that are too big to fit in the scrollback. Fixes issues with the sixel list not being sorted correctly.
2020-10-03 23:00:34 +02:00
tll_foreach(untranslated_sixels, it)
sixel: improve handling of images when reflowing the grids Update the sixels' 'row' attribute when re-flowing a grid, to ensure it is rendered at the correct place. This should work in most cases, but will break when the cell size has changed (e.g. font size increase/decrease, or a DPI change). This patch also moves the sixel image list from the terminal struct into the grid struct. The sixels are per-grid after all.
2020-03-13 18:44:23 +01:00
sixel_destroy(&it->item);
grid: reflow: re-insert sixels *after* new grid offset has been set Also make sure to destroy sixels that are too big to fit in the scrollback. Fixes issues with the sixel list not being sorted correctly.
2020-10-03 23:00:34 +02:00
tll_free(untranslated_sixels);
grid: add compile-time define to enable timing of the reflow operation
2021-05-11 17:43:17 +02:00
#if defined(TIME_REFLOW) && TIME_REFLOW
struct timeval stop;
gettimeofday(&stop, NULL);
struct timeval diff;
timersub(&stop, &start, &diff);
grid: fix 32-bit compilation
2021-05-15 12:11:58 +02:00
LOG_INFO("reflowed %d -> %d rows in %llds %lldµs",
old_rows, new_rows,
(long long)diff.tv_sec,
(long long)diff.tv_usec);
grid: add compile-time define to enable timing of the reflow operation
2021-05-11 17:43:17 +02:00
#endif
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
}
grid: add new function grid_row_add_uri_range()
2021-02-14 20:50:33 +01:00
grid: refactor: break out allocation of ‘extra’ member to separate function
2021-02-14 20:52:26 +01:00
static void
ensure_row_has_extra_data(struct row *row)
grid: add new function grid_row_add_uri_range()
2021-02-14 20:50:33 +01:00
{
if (row->extra == NULL)
row->extra = xcalloc(1, sizeof(*row->extra));
grid: refactor: break out allocation of ‘extra’ member to separate function
2021-02-14 20:52:26 +01:00
}
grid: add new function grid_row_add_uri_range()
2021-02-14 20:50:33 +01:00
grid: refactor: break out allocation of ‘extra’ member to separate function
2021-02-14 20:52:26 +01:00
void
grid_row_add_uri_range(struct row *row, struct row_uri_range range)
{
ensure_row_has_extra_data(row);
grid: row_add_uri_range: ensure the URIs are sorted
2021-05-22 17:12:58 +02:00
tll_rforeach(row->extra->uri_ranges, it) {
if (it->item.end < range.start) {
tll_insert_after(row->extra->uri_ranges, it, range);
return;
}
}
tll_push_front(row->extra->uri_ranges, range);
grid: add new function grid_row_add_uri_range()
2021-02-14 20:50:33 +01:00
}
Reference in a new issue Copy permalink