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

1690 lines
54 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: resize with reflow: reflow FTCS_COMMAND_{EXECUTED,FINISHED}
2022-12-08 13:50:30 +01:00
#include <limits.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 abs-to-sb and sb-to-abs utility function These functions convert row numbers between absolute coordinates and “scrollback relative” coordinates. Absolute row numbers can be used to index into the grid->rows[] array. Scrollback relative numbers are ordered with the *oldest* row first, and the *newest* row last. That is, in these coordinates, row 0 is the *first* (oldest) row in the scrollback history, and row N is the *last* (newest) row. Scrollback relative numbers are used when we need to sort things after their age, when determining if something has scrolled out, or when limiting an operation to ensure we don’t go past the scrollback wrap-around.
2022-04-25 19:57:18 +02:00
/*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* "sb" (scrollback relative) coordinates
grid: add abs-to-sb and sb-to-abs utility function These functions convert row numbers between absolute coordinates and “scrollback relative” coordinates. Absolute row numbers can be used to index into the grid->rows[] array. Scrollback relative numbers are ordered with the *oldest* row first, and the *newest* row last. That is, in these coordinates, row 0 is the *first* (oldest) row in the scrollback history, and row N is the *last* (newest) row. Scrollback relative numbers are used when we need to sort things after their age, when determining if something has scrolled out, or when limiting an operation to ensure we don’t go past the scrollback wrap-around.
2022-04-25 19:57:18 +02:00
*
* The scrollback relative row number 0 is the *first*, and *oldest*
* row in the scrollback history (and thus the *first* row to be
* scrolled out). Thus, a higher number means further *down* in the
* scrollback, with the *highest* number being at the bottom of the
* screen, where new input appears.
*/
osc: add support for OSC 133;A (prompt markers) This patch adds support for the OSC-133;A sequence, introduced by FinalTerm and implemented by iTerm2, Kitty and more. See https://iterm2.com/documentation-one-page.html#documentation-escape-codes.html. The shell emits the OSC just before printing the prompt. This lets the terminal know where, in the scrollback, there are prompts. We implement this using a simple boolean in the row struct ("this row has a prompt"). The prompt marker must be reflowed along with the text on window resizes. In an ideal world, erasing, or overwriting the cell where the OSC was emitted, would remove the prompt mark. Since we don't store this information in the cell struct, we can't do that. The best we can do is reset it in erase_line(). This works well enough in the "normal" screen, when used with a "normal" shell. It doesn't really work in fullscreen apps, on the alt screen. But that doesn't matter since we don't support jumping between prompts on the alt screen anyway. To be able to jump between prompts, two new key bindings have been added: prompt-prev and prompt-next, bound to ctrl+shift+z and ctrl+shift+x respectively. prompt-prev will jump to the previous, not currently visible, prompt, by moving the viewport, ensuring the prompt is at the top of the screen. prompt-next jumps to the next prompt, visible or not. Again, by moving the viewport to ensure the prompt is at the top of the screen. If we're at the bottom of the scrollback, the viewport is instead moved as far down as possible. Closes #30
2022-06-15 18:44:23 +02:00
grid: add abs-to-sb and sb-to-abs utility function These functions convert row numbers between absolute coordinates and “scrollback relative” coordinates. Absolute row numbers can be used to index into the grid->rows[] array. Scrollback relative numbers are ordered with the *oldest* row first, and the *newest* row last. That is, in these coordinates, row 0 is the *first* (oldest) row in the scrollback history, and row N is the *last* (newest) row. Scrollback relative numbers are used when we need to sort things after their age, when determining if something has scrolled out, or when limiting an operation to ensure we don’t go past the scrollback wrap-around.
2022-04-25 19:57:18 +02:00
int
grid_row_abs_to_sb(const struct grid *grid, int screen_rows, int abs_row)
{
const int scrollback_start = grid->offset + screen_rows;
int rebased_row = abs_row - scrollback_start + grid->num_rows;
rebased_row &= grid->num_rows - 1;
return rebased_row;
}
int grid_row_sb_to_abs(const struct grid *grid, int screen_rows, int sb_rel_row)
{
const int scrollback_start = grid->offset + screen_rows;
int abs_row = sb_rel_row + scrollback_start;
abs_row &= grid->num_rows - 1;
return abs_row;
}
osc: add support for OSC 133;A (prompt markers) This patch adds support for the OSC-133;A sequence, introduced by FinalTerm and implemented by iTerm2, Kitty and more. See https://iterm2.com/documentation-one-page.html#documentation-escape-codes.html. The shell emits the OSC just before printing the prompt. This lets the terminal know where, in the scrollback, there are prompts. We implement this using a simple boolean in the row struct ("this row has a prompt"). The prompt marker must be reflowed along with the text on window resizes. In an ideal world, erasing, or overwriting the cell where the OSC was emitted, would remove the prompt mark. Since we don't store this information in the cell struct, we can't do that. The best we can do is reset it in erase_line(). This works well enough in the "normal" screen, when used with a "normal" shell. It doesn't really work in fullscreen apps, on the alt screen. But that doesn't matter since we don't support jumping between prompts on the alt screen anyway. To be able to jump between prompts, two new key bindings have been added: prompt-prev and prompt-next, bound to ctrl+shift+z and ctrl+shift+x respectively. prompt-prev will jump to the previous, not currently visible, prompt, by moving the viewport, ensuring the prompt is at the top of the screen. prompt-next jumps to the next prompt, visible or not. Again, by moving the viewport to ensure the prompt is at the top of the screen. If we're at the bottom of the scrollback, the viewport is instead moved as far down as possible. Closes #30
2022-06-15 18:44:23 +02:00
int
grid_sb_start_ignore_uninitialized(const struct grid *grid, int screen_rows)
{
int scrollback_start = grid->offset + screen_rows;
scrollback_start &= grid->num_rows - 1;
while (grid->rows[scrollback_start] == NULL) {
scrollback_start++;
scrollback_start &= grid->num_rows - 1;
}
return scrollback_start;
}
int
grid_row_abs_to_sb_precalc_sb_start(const struct grid *grid, int sb_start,
int abs_row)
{
int rebased_row = abs_row - sb_start + grid->num_rows;
rebased_row &= grid->num_rows - 1;
return rebased_row;
}
int
grid_row_sb_to_abs_precalc_sb_start(const struct grid *grid, int sb_start,
int sb_rel_row)
{
int abs_row = sb_rel_row + sb_start;
abs_row &= grid->num_rows - 1;
return abs_row;
}
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
static void
ensure_row_has_extra_data(struct row *row)
{
if (row->extra == NULL)
row->extra = xcalloc(1, sizeof(*row->extra));
}
static void
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
verify_no_overlapping_ranges_of_type(const struct row_ranges *ranges,
enum row_range_type type)
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
{
#if defined(_DEBUG)
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
for (size_t i = 0; i < ranges->count; i++) {
const struct row_range *r1 = &ranges->v[i];
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
for (size_t j = i + 1; j < ranges->count; j++) {
const struct row_range *r2 = &ranges->v[j];
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
xassert(r1 != r2);
if ((r1->start <= r2->start && r1->end >= r2->start) ||
(r1->start <= r2->end && r1->end >= r2->end))
{
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
switch (type) {
case ROW_RANGE_URI:
BUG("OSC-8 URI overlap: %s: %d-%d: %s: %d-%d",
r1->uri.uri, r1->start, r1->end,
r2->uri.uri, r2->start, r2->end);
break;
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
case ROW_RANGE_CURLY:
BUG("curly underline overlap: %d-%d, %d-%d",
r1->start, r1->end, r2->start, r2->end);
break;
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
}
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
}
}
}
#endif
}
static void
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
verify_no_overlapping_ranges(const struct row_data *extra)
{
verify_no_overlapping_ranges_of_type(&extra->uri_ranges, ROW_RANGE_URI);
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
verify_no_overlapping_ranges_of_type(&extra->curly_ranges, ROW_RANGE_CURLY);
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
}
static void
verify_ranges_of_type_are_sorted(const struct row_ranges *ranges,
enum row_range_type type)
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
{
#if defined(_DEBUG)
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
const struct row_range *last = NULL;
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
for (size_t i = 0; i < ranges->count; i++) {
const struct row_range *r = &ranges->v[i];
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
if (last != NULL) {
if (last->start >= r->start || last->end >= r->end) {
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
switch (type) {
case ROW_RANGE_URI:
BUG("OSC-8 URI not sorted correctly: "
"%s: %d-%d came before %s: %d-%d",
last->uri.uri, last->start, last->end,
r->uri.uri, r->start, r->end);
break;
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
case ROW_RANGE_CURLY:
BUG("curly ranges not sorted correctly: "
"%d-%d came before %d-%d",
last->start, last->end, r->start, r->end);
break;
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
}
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
}
}
last = r;
}
#endif
}
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
static void
verify_ranges_are_sorted(const struct row_data *extra)
{
verify_ranges_of_type_are_sorted(&extra->uri_ranges, ROW_RANGE_URI);
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
verify_ranges_of_type_are_sorted(&extra->curly_ranges, ROW_RANGE_CURLY);
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
}
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
static void
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
range_ensure_size(struct row_ranges *ranges, int count_to_add)
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
{
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
if (ranges->count + count_to_add > ranges->size) {
ranges->size = ranges->count + count_to_add;
ranges->v = xrealloc(ranges->v, ranges->size * sizeof(ranges->v[0]));
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
}
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
xassert(ranges->count + count_to_add <= ranges->size);
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
}
grid: refactor: remove union range_data_for_insertion This union is identical to row_range_data, except the URI char pointer is const. Let's ignore that, and re-use row_range_data, casting the URI pointer when necessary. Also remove uri_range_insert() and curly_range_insert(), and use the generic version of range_insert() everywhere.
2024-06-25 10:26:07 +02:00
/*
* Be careful! This function may xrealloc() the URI range vector, thus
* invalidating pointers into it.
*/
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
static void
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
range_insert(struct row_ranges *ranges, size_t idx, int start, int end,
grid: refactor: remove union range_data_for_insertion This union is identical to row_range_data, except the URI char pointer is const. Let's ignore that, and re-use row_range_data, casting the URI pointer when necessary. Also remove uri_range_insert() and curly_range_insert(), and use the generic version of range_insert() everywhere.
2024-06-25 10:26:07 +02:00
enum row_range_type type, const union row_range_data *data)
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
{
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
range_ensure_size(ranges, 1);
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
xassert(idx <= ranges->count);
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
const size_t move_count = ranges->count - idx;
memmove(&ranges->v[idx + 1],
&ranges->v[idx],
move_count * sizeof(ranges->v[0]));
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
ranges->count++;
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
struct row_range *r = &ranges->v[idx];
r->start = start;
r->end = end;
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
switch (type) {
case ROW_RANGE_URI:
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
r->uri.id = data->uri.id;
r->uri.uri = xstrdup(data->uri.uri);
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
break;
case ROW_RANGE_CURLY:
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
r->curly = data->curly;
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
break;
}
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
}
static void
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append_by_ref(struct row_ranges *ranges, int start, int end,
enum row_range_type type, const union row_range_data *data)
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
{
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_ensure_size(ranges, 1);
grid: uri_range_{append,insert}: pass range attributes as separate parameters
2021-11-27 16:24:26 +01:00
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
struct row_range *r = &ranges->v[ranges->count++];
r->start = start;
r->end = end;
switch (type) {
case ROW_RANGE_URI:
r->uri.id = data->uri.id;;
r->uri.uri = data->uri.uri;
break;
case ROW_RANGE_CURLY:
r->curly = data->curly;
break;
}
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
}
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
static void
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append(struct row_ranges *ranges, int start, int end,
enum row_range_type type, const union row_range_data *data)
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
{
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
switch (type) {
case ROW_RANGE_URI:
range_append_by_ref(
ranges, start, end, type,
&(union row_range_data){.uri = {.id = data->uri.id,
.uri = xstrdup(data->uri.uri)}});
break;
case ROW_RANGE_CURLY:
range_append_by_ref(ranges, start, end, type, data);
break;
}
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
}
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
static void
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
range_delete(struct row_ranges *ranges, enum row_range_type type, size_t idx)
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
{
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
xassert(idx < ranges->count);
grid_row_range_destroy(&ranges->v[idx], type);
const size_t move_count = ranges->count - idx - 1;
memmove(&ranges->v[idx],
&ranges->v[idx + 1],
move_count * sizeof(ranges->v[0]));
ranges->count--;
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01: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;
render: delay reflow for ‘resize-delay-ms’ milliseconds Reflowing a large scrollback is *slow*. During an interactive resize, it can easily take long enough that the compositor fills the Wayland socket with configure events. Eventually, the socket becomes full and the compositor terminates the connection, causing foot to exit. This patch is work-in-progress, and the first step towards alleviating this. It delays the reflow by: * Snapshotting (copying) the original grid when an interactive resize is started. * While resizing, we apply a simple truncation resize of the grid (like we handle the alt screen). * When the resize is done, or paused for ‘resize-delay-ms’, the grid is reflowed. TODO: we *must* not allow any changes to the temporary (truncated) grid during the resize. Any changes to the grid would be lost when the final reflow is applied. That is, we must completely pause the ptmx pipe while a resize is in progress. Future improvements: The initial copy can be slow. We should be able to avoid it by rewriting the reflow algorithm to not free anything. This is complicated by the fact that some resources (e.g. sixel images) are currently *moved* to the new grid. They’d instead have to be copied.
2022-10-05 17:05:44 +02:00
clone->saved_cursor = grid->saved_cursor;
clone->kitty_kbd = grid->kitty_kbd;
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->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;
term: move row->prompt_marker into new struct, row->shell_integration
2022-12-08 10:35:30 +01:00
clone_row->shell_integration = row->shell_integration;
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];
grid: snapshot: use uri range utility functions
2021-11-27 16:07:50 +01:00
const struct row_data *extra = row->extra;
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
grid: snapshot: use uri range utility functions
2021-11-27 16:07:50 +01:00
if (extra != NULL) {
grid: uri_range_{append,insert}: pass range attributes as separate parameters
2021-11-27 16:24:26 +01:00
struct row_data *clone_extra = xcalloc(1, sizeof(*clone_extra));
clone_row->extra = clone_extra;
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
range_ensure_size(&clone_extra->uri_ranges, extra->uri_ranges.count);
range_ensure_size(&clone_extra->curly_ranges, extra->curly_ranges.count);
grid: add grid_snapshot() This function deep copies a grid into a newly *allocated* grid struct.
2021-02-22 10:21:58 +01:00
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
for (int i = 0; i < extra->uri_ranges.count; i++) {
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
const struct row_range *range = &extra->uri_ranges.v[i];
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append(
&clone_extra->uri_ranges,
range->start, range->end, ROW_RANGE_URI, &range->data);
grid: add grid_snapshot() This function deep copies a grid into a newly *allocated* grid struct.
2021-02-22 10:21:58 +01:00
}
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
for (int i = 0; i < extra->curly_ranges.count; i++) {
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
const struct row_range *range = &extra->curly_ranges.v[i];
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append_by_ref(
&clone_extra->curly_ranges, range->start, range->end,
ROW_RANGE_CURLY, &range->data);
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +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
} else
clone_row->extra = NULL;
}
tll_foreach(grid->sixel_images, it) {
sixel: re-scale images when the cell dimensions change Before this patch, when the cell dimensions changed (i.e. when the font size changes), sixel images were either removed (the new cell dimensions are smaller than the old), or simply kept at their original size (new cell dimensions are larger). With this patch, sixels are instead resized. This means a sixel *always* occupies the same number of rows and columns, regardless of how much the font size is changed. This is done by maintaining two sets of image data and pixman images, as well as their dimensions. These two sets are the new ‘original’ and ‘scaled’ members of the sixel struct. The "top-level" pixman image pointer, and the ‘width’ and ‘height’ members either point to the "original", or the "scaled" version. They are invalidated as soon as the cell dimensions change. They, and the ‘scaled’ image is updated on-demand (when we need to render a sixel). Note that the ‘scaled’ image is always NULL when the current cell dimensions matches the ones used when emitting the sixel (to save run-time memory). Closes #1383
2023-06-29 14:49:54 +02:00
int original_width = it->item.original.width;
int original_height = it->item.original.height;
pixman_image_t *original_pix = it->item.original.pix;
pixman_format_code_t original_pix_fmt = pixman_image_get_format(original_pix);
int original_stride = stride_for_format_and_width(original_pix_fmt, original_width);
size_t original_size = original_stride * original_height;
xmalloc: add xmemdup() and use to replace some uses of xmalloc+memcpy
2024-03-16 20:28:10 +00:00
void *new_original_data = xmemdup(it->item.original.data, original_size);
sixel: re-scale images when the cell dimensions change Before this patch, when the cell dimensions changed (i.e. when the font size changes), sixel images were either removed (the new cell dimensions are smaller than the old), or simply kept at their original size (new cell dimensions are larger). With this patch, sixels are instead resized. This means a sixel *always* occupies the same number of rows and columns, regardless of how much the font size is changed. This is done by maintaining two sets of image data and pixman images, as well as their dimensions. These two sets are the new ‘original’ and ‘scaled’ members of the sixel struct. The "top-level" pixman image pointer, and the ‘width’ and ‘height’ members either point to the "original", or the "scaled" version. They are invalidated as soon as the cell dimensions change. They, and the ‘scaled’ image is updated on-demand (when we need to render a sixel). Note that the ‘scaled’ image is always NULL when the current cell dimensions matches the ones used when emitting the sixel (to save run-time memory). Closes #1383
2023-06-29 14:49:54 +02:00
pixman_image_t *new_original_pix = pixman_image_create_bits_no_clear(
original_pix_fmt, original_width, original_height,
new_original_data, original_stride);
void *new_scaled_data = NULL;
pixman_image_t *new_scaled_pix = NULL;
int scaled_width = -1;
int scaled_height = -1;
if (it->item.scaled.data != NULL) {
scaled_width = it->item.scaled.width;
scaled_height = it->item.scaled.height;
pixman_image_t *scaled_pix = it->item.scaled.pix;
pixman_format_code_t scaled_pix_fmt = pixman_image_get_format(scaled_pix);
int scaled_stride = stride_for_format_and_width(scaled_pix_fmt, scaled_width);
size_t scaled_size = scaled_stride * scaled_height;
xmalloc: add xmemdup() and use to replace some uses of xmalloc+memcpy
2024-03-16 20:28:10 +00:00
new_scaled_data = xmemdup(it->item.scaled.data, scaled_size);
sixel: re-scale images when the cell dimensions change Before this patch, when the cell dimensions changed (i.e. when the font size changes), sixel images were either removed (the new cell dimensions are smaller than the old), or simply kept at their original size (new cell dimensions are larger). With this patch, sixels are instead resized. This means a sixel *always* occupies the same number of rows and columns, regardless of how much the font size is changed. This is done by maintaining two sets of image data and pixman images, as well as their dimensions. These two sets are the new ‘original’ and ‘scaled’ members of the sixel struct. The "top-level" pixman image pointer, and the ‘width’ and ‘height’ members either point to the "original", or the "scaled" version. They are invalidated as soon as the cell dimensions change. They, and the ‘scaled’ image is updated on-demand (when we need to render a sixel). Note that the ‘scaled’ image is always NULL when the current cell dimensions matches the ones used when emitting the sixel (to save run-time memory). Closes #1383
2023-06-29 14:49:54 +02:00
new_scaled_pix = pixman_image_create_bits_no_clear(
scaled_pix_fmt, scaled_width, scaled_height, new_scaled_data,
scaled_stride);
}
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 sixel six = {
sixel: re-scale images when the cell dimensions change Before this patch, when the cell dimensions changed (i.e. when the font size changes), sixel images were either removed (the new cell dimensions are smaller than the old), or simply kept at their original size (new cell dimensions are larger). With this patch, sixels are instead resized. This means a sixel *always* occupies the same number of rows and columns, regardless of how much the font size is changed. This is done by maintaining two sets of image data and pixman images, as well as their dimensions. These two sets are the new ‘original’ and ‘scaled’ members of the sixel struct. The "top-level" pixman image pointer, and the ‘width’ and ‘height’ members either point to the "original", or the "scaled" version. They are invalidated as soon as the cell dimensions change. They, and the ‘scaled’ image is updated on-demand (when we need to render a sixel). Note that the ‘scaled’ image is always NULL when the current cell dimensions matches the ones used when emitting the sixel (to save run-time memory). Closes #1383
2023-06-29 14:49:54 +02:00
.pix = (it->item.pix == it->item.original.pix
? new_original_pix
: (it->item.pix == it->item.scaled.pix
? new_scaled_pix
: NULL)),
.width = it->item.width,
.height = it->item.height,
grid: add grid_snapshot() This function deep copies a grid into a newly *allocated* grid struct.
2021-02-22 10:21:58 +01:00
.rows = it->item.rows,
.cols = it->item.cols,
.pos = it->item.pos,
sixel: re-scale images when the cell dimensions change Before this patch, when the cell dimensions changed (i.e. when the font size changes), sixel images were either removed (the new cell dimensions are smaller than the old), or simply kept at their original size (new cell dimensions are larger). With this patch, sixels are instead resized. This means a sixel *always* occupies the same number of rows and columns, regardless of how much the font size is changed. This is done by maintaining two sets of image data and pixman images, as well as their dimensions. These two sets are the new ‘original’ and ‘scaled’ members of the sixel struct. The "top-level" pixman image pointer, and the ‘width’ and ‘height’ members either point to the "original", or the "scaled" version. They are invalidated as soon as the cell dimensions change. They, and the ‘scaled’ image is updated on-demand (when we need to render a sixel). Note that the ‘scaled’ image is always NULL when the current cell dimensions matches the ones used when emitting the sixel (to save run-time memory). Closes #1383
2023-06-29 14:49:54 +02:00
.opaque = it->item.opaque,
.cell_width = it->item.cell_width,
.cell_height = it->item.cell_height,
.original = {
.data = new_original_data,
.pix = new_original_pix,
.width = original_width,
.height = original_height,
},
.scaled = {
.data = new_scaled_data,
.pix = new_scaled_pix,
.width = scaled_width,
.height = scaled_height,
},
grid: add grid_snapshot() This function deep copies a grid into a newly *allocated* grid struct.
2021-02-22 10:21:58 +01:00
};
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)
{
grid_free(): allow being called with grid == NULL
2022-10-18 18:30:02 +02:00
if (grid == NULL)
return;
grid: add grid_free()
2021-02-22 10:20:52 +01:00
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;
Revert "grid: invert the default value of ‘linebreak’, from false to true" This reverts commit cdd46cdf85b1087ac7465c646bb05078f1bbe85b.
2022-06-30 19:37:01 +02: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;
term: move row->prompt_marker into new struct, row->shell_integration
2022-12-08 10:35:30 +01:00
row->shell_integration.prompt_marker = false;
osc: store column of FTCS_COMMAND_{EXECUTED,FINISHED} in row struct
2022-12-08 10:46:46 +01:00
row->shell_integration.cmd_start = -1;
row->shell_integration.cmd_end = -1;
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;
grid: resize without reflow: truncate shell_integration.cmd_{start,end} This ensures the cmd start/end columns are valid in the new grid.
2022-12-08 13:49:38 +01:00
new_row->shell_integration.prompt_marker = old_row->shell_integration.prompt_marker;
new_row->shell_integration.cmd_start = min(old_row->shell_integration.cmd_start, new_cols - 1);
new_row->shell_integration.cmd_end = min(old_row->shell_integration.cmd_end, new_cols - 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
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 */
grid: resize without reflowing: use URI range utility functions
2021-11-27 16:31:33 +01:00
const struct row_data *old_extra = old_row->extra;
if (old_extra == NULL)
grid: grid_resize_without_reflow: transfer URI ranges
2021-02-14 20:42:42 +01:00
continue;
grid: resize without reflowing: use URI range utility functions
2021-11-27 16:31:33 +01:00
ensure_row_has_extra_data(new_row);
struct row_data *new_extra = new_row->extra;
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
range_ensure_size(&new_extra->uri_ranges, old_extra->uri_ranges.count);
range_ensure_size(&new_extra->curly_ranges, old_extra->curly_ranges.count);
grid: resize without reflowing: use URI range utility functions
2021-11-27 16:31:33 +01:00
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
for (int i = 0; i < old_extra->uri_ranges.count; i++) {
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
const struct row_range *range = &old_extra->uri_ranges.v[i];
grid: resize without reflowing: use URI range utility functions
2021-11-27 16:31:33 +01:00
if (range->start >= new_cols) {
grid: grid_resize_without_reflow: transfer URI ranges
2021-02-14 20:42:42 +01:00
/* The whole range is truncated */
continue;
}
grid: resize without reflowing: use URI range utility functions
2021-11-27 16:31:33 +01:00
const int start = range->start;
const int end = min(range->end, new_cols - 1);
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append(&new_extra->uri_ranges, start, end, ROW_RANGE_URI, &range->data);
grid: grid_resize_without_reflow: transfer URI ranges
2021-02-14 20:42:42 +01:00
}
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
for (int i = 0; i < old_extra->curly_ranges.count; i++) {
const struct row_range *range = &old_extra->curly_ranges.v[i];
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
if (range->start >= new_cols) {
/* The whole range is truncated */
continue;
}
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
const int start = range->start;
const int end = min(range->end, new_cols - 1);
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append_by_ref(&new_extra->curly_ranges, start, end, ROW_RANGE_CURLY, &range->data);
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +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
/* 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;
}
grid: resize without reflow: only verify URI ranges in debug builds
2021-11-26 20:36:59 +01:00
#if defined(_DEBUG)
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
for (size_t r = 0; r < new_rows; r++) {
const struct row *row = new_grid[r];
if (row == NULL)
continue;
if (row->extra == NULL)
continue;
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
verify_no_overlapping_ranges(row->extra);
verify_ranges_are_sorted(row->extra);
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
}
grid: resize without reflow: only verify URI ranges in debug builds
2021-11-26 20:36:59 +01:00
#endif
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +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
/* 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: resize: assert grid->cur_row is not NULL after a grid resize
2022-10-09 16:12:18 +02:00
xassert(grid->cur_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
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: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
reflow_uri_range_start(struct row_range *range, struct row *new_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
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
{
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
ensure_row_has_extra_data(new_row);
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append_by_ref(
&new_row->extra->uri_ranges, new_col_idx, -1,
ROW_RANGE_URI, &range->data);
/* The reflowed range now owns the URI string */
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
range->uri.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: 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
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
reflow_uri_range_end(struct row_range *range, struct row *new_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
int new_col_idx)
{
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
struct row_data *extra = new_row->extra;
xassert(extra->uri_ranges.count > 0);
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
struct row_range *new_range =
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
&extra->uri_ranges.v[extra->uri_ranges.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: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
xassert(new_range->uri.id == range->uri.id);
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->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
}
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
static void
reflow_curly_range_start(struct row_range *range, struct row *new_row,
int new_col_idx)
{
ensure_row_has_extra_data(new_row);
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append_by_ref(&new_row->extra->curly_ranges, new_col_idx, -1,
ROW_RANGE_CURLY, &range->data);
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
}
static void
reflow_curly_range_end(struct row_range *range, struct row *new_row,
int new_col_idx)
{
struct row_data *extra = new_row->extra;
xassert(extra->curly_ranges.count > 0);
struct row_range *new_range =
&extra->curly_ranges.v[extra->curly_ranges.count - 1];
xassert(new_range->curly.style == range->curly.style);
xassert(new_range->curly.color_src == range->curly.color_src);
xassert(new_range->curly.color == range->curly.color);
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 {
Codespell fixes
2023-10-03 14:11:55 +02:00
/* Scrollback is full, need to reuse a row */
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_row_reset_extra(new_row);
Revert "grid: invert the default value of ‘linebreak’, from false to true" This reverts commit cdd46cdf85b1087ac7465c646bb05078f1bbe85b.
2022-06-30 19:37:01 +02:00
new_row->linebreak = false;
term: move row->prompt_marker into new struct, row->shell_integration
2022-12-08 10:35:30 +01:00
new_row->shell_integration.prompt_marker = false;
osc: store column of FTCS_COMMAND_{EXECUTED,FINISHED} in row struct
2022-12-08 10:46:46 +01:00
new_row->shell_integration.cmd_start = -1;
new_row->shell_integration.cmd_end = -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
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);
}
}
grid: reflow: add TODO to detect selection on re-used rows, and cancel it
2022-02-07 13:57:25 +01:00
/*
Codespell fixes
2023-10-03 14:11:55 +02:00
* TODO: detect if the reused row is covered by the
grid: reflow: add TODO to detect selection on re-used rows, and cancel it
2022-02-07 13:57:25 +01:00
* selection. Of so, cancel the selection. The problem: we
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* don't know if we've translated the selection coordinates
grid: reflow: add TODO to detect selection on re-used rows, and cancel it
2022-02-07 13:57:25 +01:00
* yet.
*/
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
}
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
struct row_data *extra = row->extra;
if (extra == 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
return new_row;
/*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* URI ranges are per row. Thus, we need to 'close' the still-open
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
* ranges on the previous row, and re-open them on the
* next/current row.
*/
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
if (extra->uri_ranges.count > 0) {
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
struct row_range *range =
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
&extra->uri_ranges.v[extra->uri_ranges.count - 1];
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 (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 */
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
ensure_row_has_extra_data(new_row);
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append(&new_row->extra->uri_ranges, 0, -1,
ROW_RANGE_URI, &range->data);
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: 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: handle styled underlines
2024-06-24 00:57:03 +02:00
if (extra->curly_ranges.count > 0) {
struct row_range *range =
&extra->curly_ranges.v[extra->curly_ranges.count - 1];
if (range->end < 0) {
/* Terminate URI range on the previous row */
range->end = col_count - 1;
/* Open a new range on the new/current row */
ensure_row_has_extra_data(new_row);
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append(&new_row->extra->curly_ranges, 0, -1,
ROW_RANGE_CURLY, &range->data);
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02: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
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
replace gettimeofday with clock_gettime POSIX.1-2008 has marked gettimeofday(2) as obsolete, recommending the use of clock_gettime(2) instead. CLOCK_MONOTONIC has been used instead of CLOCK_REALTIME because it is unaffected by manual changes in the system clock. This makes it better for our purposes, namely, measuring the difference between two points in time. tv_sec has been casted to long in most places since POSIX does not define the actual type of time_t.
2022-01-15 14:56:13 +05:30
struct timespec start;
clock_gettime(CLOCK_MONOTONIC, &start);
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
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;
}
}
grid: reflow: require col count > 0 when skipping line truncation When reflowing the grid, we truncate lines with a hard linebreak after the last non-empty cell. This way we don’t reflow trailing empty cells to a new line when resizing the window to a smaller size. However, “logical” lines (i.e. those without a hard linebreak) are *not* truncated. This is to ensure we don’t trim empty cells in the middle of a logical line spanning multiple physical lines. Since newly allocated rows are initialized with linebreak=false, we need to ensure _those_ are still truncated - otherwise all that empty space under the current prompt will be reflowed. Note that this is a temporary workaround. The correct solution, I think, is to track whether a line has been printed to or not, and simply ignore (not reflow) lines that haven’t yet been touched.
2022-06-30 19:47:18 +02:00
if (!old_row->linebreak && col_count > 0) {
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
/* Don't truncate logical lines */
grid: reflow: don’t trim trailing empty cells from logical lines When a line in the old grid (the one being reflowed) doesn’t have a hard linebreak, don’t trim trailing empty cells. Doing so means we’ll “compress” (remove) empty cells between text if/when we revert to a larger window size. The output from neofetch suffers from this; it prints a logo to the left, and system information to the right. The logo and the system info column is separated by empty cells (i.e. *not* spaces). If the window is reduced in size such that the system info is pushed to a new line, each logo line ends with a number of empty cells. The next time the window is resized, these empty cells were ignored (i.e. removed). That meant that once the window was enlarged again, the system info column was a) no longer aligned, and b) had been pulled closer to the logo. This patch doesn’t special case trailing empty cells when the line being reflowed doesn’t have a hard linebreak. This means e.g. ‘ls’ output is unaffected. Closes #1055
2022-06-01 19:29:30 +02:00
col_count = old_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
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? */
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
struct row_range *uri_range, *uri_range_terminator;
struct row_range *curly_range, *curly_range_terminator;
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
struct row_data *extra = old_row->extra;
if (extra != NULL && extra->uri_ranges.count > 0) {
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
uri_range = &extra->uri_ranges.v[0];
uri_range_terminator = &extra->uri_ranges.v[extra->uri_ranges.count];
grid: reflow: when determining row end coord, check *last* URI range
2021-05-28 17:42:09 +02:00
grid: reflow: no need to keep a uri-range-idx variable The URI ranges are now an array, which means we can get the next URI range by incrementing the pointer. Instead of checking if range is not NULL, check that it isn’t the range terminator (which is NULL when we don’t have any ranges, and the first address *after* the last range otherwise).
2021-11-26 20:57:08 +01:00
/* Make sure the *last* URI range's end point is included
* in the copy */
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
const struct row_range *last_on_row =
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
&extra->uri_ranges.v[extra->uri_ranges.count - 1];
grid: reflow: when determining row end coord, check *last* URI range
2021-05-28 17:42:09 +02:00
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
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
uri_range = uri_range_terminator = NULL;
if (extra != NULL && extra->curly_ranges.count > 0) {
curly_range = &extra->curly_ranges.v[0];
curly_range_terminator = &extra->curly_ranges.v[extra->curly_ranges.count];
const struct row_range *last_on_row =
&extra->curly_ranges.v[extra->curly_ranges.count - 1];
col_count = max(col_count, last_on_row->end + 1);
} else
curly_range = curly_range_terminator = 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: handle styled underlines
2024-06-24 00:57:03 +02:00
bool curly_break = false;
grid: resize with reflow: reflow FTCS_COMMAND_{EXECUTED,FINISHED}
2022-12-08 13:50:30 +01:00
bool ftcs_break = false;
grid: set tp/uri break flags explicitly when we know them to be true
2021-05-25 19:31:38 +02:00
grid: resize with reflow: reflow FTCS_COMMAND_{EXECUTED,FINISHED}
2022-12-08 13:50:30 +01:00
/* Figure out where to end this chunk */
{
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
const int uri_col = uri_range != uri_range_terminator
? ((uri_range->start >= start ? uri_range->start : uri_range->end) + 1)
: INT_MAX;
const int curly_col = curly_range != curly_range_terminator
? ((curly_range->start >= start ? curly_range->start : curly_range->end) + 1)
grid: resize with reflow: reflow FTCS_COMMAND_{EXECUTED,FINISHED}
2022-12-08 13:50:30 +01:00
: INT_MAX;
const int tp_col = tp != NULL ? tp->col + 1 : INT_MAX;
const int ftcs_col = old_row->shell_integration.cmd_start >= start
? old_row->shell_integration.cmd_start + 1
: old_row->shell_integration.cmd_end >= start
? old_row->shell_integration.cmd_end + 1
: INT_MAX;
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
end = min(col_count, min(min(tp_col, min(uri_col, curly_col)), ftcs_col));
grid: resize with reflow: reflow FTCS_COMMAND_{EXECUTED,FINISHED}
2022-12-08 13:50:30 +01:00
uri_break = end == uri_col;
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
curly_break = end == curly_col;
grid: resize with reflow: reflow FTCS_COMMAND_{EXECUTED,FINISHED}
2022-12-08 13:50:30 +01:00
tp_break = end == tp_col;
ftcs_break = end == ftcs_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
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
/*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01: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
grid: reflow: comments
2021-05-25 19:40:10 +02:00
* 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
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* that doesn't fit on the current row. We need to
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
* 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);
osc: add support for OSC 133;A (prompt markers) This patch adds support for the OSC-133;A sequence, introduced by FinalTerm and implemented by iTerm2, Kitty and more. See https://iterm2.com/documentation-one-page.html#documentation-escape-codes.html. The shell emits the OSC just before printing the prompt. This lets the terminal know where, in the scrollback, there are prompts. We implement this using a simple boolean in the row struct ("this row has a prompt"). The prompt marker must be reflowed along with the text on window resizes. In an ideal world, erasing, or overwriting the cell where the OSC was emitted, would remove the prompt mark. Since we don't store this information in the cell struct, we can't do that. The best we can do is reset it in erase_line(). This works well enough in the "normal" screen, when used with a "normal" shell. It doesn't really work in fullscreen apps, on the alt screen. But that doesn't matter since we don't support jumping between prompts on the alt screen anyway. To be able to jump between prompts, two new key bindings have been added: prompt-prev and prompt-next, bound to ctrl+shift+z and ctrl+shift+x respectively. prompt-prev will jump to the previous, not currently visible, prompt, by moving the viewport, ensuring the prompt is at the top of the screen. prompt-next jumps to the next prompt, visible or not. Again, by moving the viewport to ensure the prompt is at the top of the screen. If we're at the bottom of the scrollback, the viewport is instead moved as far down as possible. Closes #30
2022-06-15 18:44:23 +02:00
if (from == 0)
grid: resize with reflow: reflow FTCS_COMMAND_{EXECUTED,FINISHED}
2022-12-08 13:50:30 +01:00
new_row->shell_integration.prompt_marker = old_row->shell_integration.prompt_marker;
osc: add support for OSC 133;A (prompt markers) This patch adds support for the OSC-133;A sequence, introduced by FinalTerm and implemented by iTerm2, Kitty and more. See https://iterm2.com/documentation-one-page.html#documentation-escape-codes.html. The shell emits the OSC just before printing the prompt. This lets the terminal know where, in the scrollback, there are prompts. We implement this using a simple boolean in the row struct ("this row has a prompt"). The prompt marker must be reflowed along with the text on window resizes. In an ideal world, erasing, or overwriting the cell where the OSC was emitted, would remove the prompt mark. Since we don't store this information in the cell struct, we can't do that. The best we can do is reset it in erase_line(). This works well enough in the "normal" screen, when used with a "normal" shell. It doesn't really work in fullscreen apps, on the alt screen. But that doesn't matter since we don't support jumping between prompts on the alt screen anyway. To be able to jump between prompts, two new key bindings have been added: prompt-prev and prompt-next, bound to ctrl+shift+z and ctrl+shift+x respectively. prompt-prev will jump to the previous, not currently visible, prompt, by moving the viewport, ensuring the prompt is at the top of the screen. prompt-next jumps to the next prompt, visible or not. Again, by moving the viewport to ensure the prompt is at the top of the screen. If we're at the bottom of the scrollback, the viewport is instead moved as far down as possible. Closes #30
2022-06-15 18:44:23 +02:00
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
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: handle styled underlines
2024-06-24 00:57:03 +02:00
xassert(uri_range != NULL);
if (uri_range->start == end - 1)
reflow_uri_range_start(uri_range, new_row, new_col_idx - 1);
if (uri_range->end == end - 1) {
reflow_uri_range_end(uri_range, new_row, new_col_idx - 1);
grid_row_uri_range_destroy(uri_range);
uri_range++;
}
}
if (curly_break) {
xassert(curly_range != NULL);
grid: reflow: no need to keep a uri-range-idx variable The URI ranges are now an array, which means we can get the next URI range by incrementing the pointer. Instead of checking if range is not NULL, check that it isn’t the range terminator (which is NULL when we don’t have any ranges, and the first address *after* the last range otherwise).
2021-11-26 20:57:08 +01:00
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
if (curly_range->start == end - 1)
reflow_curly_range_start(curly_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: handle styled underlines
2024-06-24 00:57:03 +02:00
if (curly_range->end == end - 1) {
reflow_curly_range_end(curly_range, new_row, new_col_idx - 1);
grid_row_curly_range_destroy(curly_range);
curly_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
}
}
grid: resize with reflow: reflow FTCS_COMMAND_{EXECUTED,FINISHED}
2022-12-08 13:50:30 +01:00
if (ftcs_break) {
xassert(old_row->shell_integration.cmd_start == start + cols - 1 ||
old_row->shell_integration.cmd_end == start + cols - 1);
if (old_row->shell_integration.cmd_start == start + cols - 1)
new_row->shell_integration.cmd_start = new_col_idx - 1;
if (old_row->shell_integration.cmd_end == start + cols - 1)
new_row->shell_integration.cmd_end = 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
left -= cols;
start += cols;
}
Revert "grid: invert the default value of ‘linebreak’, from false to true" This reverts commit cdd46cdf85b1087ac7465c646bb05078f1bbe85b.
2022-06-30 19:37:01 +02: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: don’t line-wrap the last row Before this patch, we would line-wrap the last row, just like any other row, and then afterwards try to reverse this, by adjusting the offset and free:ing and NULL:ing the "last row". The problem with this is if the scrollback is full. In this case, the row we’re freeing is the first row in the scrollback history. This means we’ll crash as soon as the viewport is moved to the top of the scrollback. The fix is fairly, simple. Skip the post-processing logic, and instead detect when we’re line-wrapping the last row, and skip the call to line_wrap(). This way, the last row in the new grid corresponds to the last row in the old grid.
2022-08-29 20:47:33 +02:00
if (r + 1 < old_rows)
line_wrap();
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
else if (new_row->extra != NULL) {
if (new_row->extra->uri_ranges.count > 0) {
/*
* line_wrap() "closes" still-open URIs. Since
* this is the *last* row, and since we're
* line-breaking due to a hard line-break (rather
* than running out of cells in the "new_row"),
* there shouldn't be an open URI (it would have
* been closed when we reached the end of the URI
* while reflowing the last "old" row).
*/
int last_idx = new_row->extra->uri_ranges.count - 1;
xassert(new_row->extra->uri_ranges.v[last_idx].end >= 0);
}
if (new_row->extra->curly_ranges.count > 0) {
int last_idx = new_row->extra->curly_ranges.count - 1;
xassert(new_row->extra->curly_ranges.v[last_idx].end >= 0);
}
grid: reflow: assert there aren’t any open URIs on the last row
2022-08-29 21:03:21 +02:00
}
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)
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
/* Verify all URI ranges have been "closed" */
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
for (int r = 0; r < new_rows; r++) {
const struct row *row = new_grid[r];
if (row == NULL)
continue;
if (row->extra == NULL)
continue;
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
for (size_t i = 0; i < row->extra->uri_ranges.count; i++)
xassert(row->extra->uri_ranges.v[i].end >= 0);
grid: reflow: handle styled underlines
2024-06-24 00:57:03 +02:00
for (size_t i = 0; i < row->extra->curly_ranges.count; i++)
xassert(row->extra->curly_ranges.v[i].end >= 0);
osc8: replace grid_row_uri_range_add() with internal uri_range_append() grid_row_uri_range_add() was only used while reflowing. In this case, we know the new URIs being added are always going at the end of the URI list (since we’re going top-to-bottom, left-to-right). Thus, we don’t need the insertion logic, and can simply append instead.
2021-11-26 20:25:07 +01:00
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
verify_no_overlapping_ranges(row->extra);
verify_ranges_are_sorted(row->extra);
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: 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;
grid: get rid of empty row at the bottom after reflowing When the window is resized and we reflow the text, we ended up inserting an empty row at the bottom. This happens whenever the actual last row has a hard linebreak (which almost always is the case); we then end the reflow with a line break, causing an extra, empty, row to be allocated and inserted. This patch fixes this by detecting when: 1) the last row is empty 2) the next to last row has a hard line break In this case, we roll back the last line break, by adjusting the new offset we just calculated, and free:ing the empty row. TODO: it would be nice if we could detect this in the reflow loop instead, and avoid doing the last line break all together. I haven’t yet been able to find a way to do this correctly. Closes #1108
2022-08-05 18:26:37 +02:00
render/grid: move grid reflow code to grid.c
2020-02-15 22:19:08 +01:00
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: 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: when setting the new viewport, ensure it’s correctly bounded Do this by using scrollback relative coordinates, and ensure the new viewport is not larger than (grid_rows - screen_rows), as that would mean the viewport crosses the scrollback wrap-around.
2022-08-29 20:46:19 +02:00
/*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* Set new viewport, making sure it's not too far down.
grid: when setting the new viewport, ensure it’s correctly bounded Do this by using scrollback relative coordinates, and ensure the new viewport is not larger than (grid_rows - screen_rows), as that would mean the viewport crosses the scrollback wrap-around.
2022-08-29 20:46:19 +02:00
*
* This is done by using scrollback-start relative cooardinates,
* and bounding the new viewport to (grid_rows - screen_rows).
*/
int sb_view = grid_row_abs_to_sb(
grid, new_screen_rows, view_follows ? grid->offset : viewport.row);
grid->view = grid_row_sb_to_abs(
grid, new_screen_rows, min(sb_view, new_rows - new_screen_rows));
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: resize: assert grid->cur_row is not NULL after a grid resize
2022-10-09 16:12:18 +02:00
xassert(grid->cur_row != NULL);
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
replace gettimeofday with clock_gettime POSIX.1-2008 has marked gettimeofday(2) as obsolete, recommending the use of clock_gettime(2) instead. CLOCK_MONOTONIC has been used instead of CLOCK_REALTIME because it is unaffected by manual changes in the system clock. This makes it better for our purposes, namely, measuring the difference between two points in time. tv_sec has been casted to long in most places since POSIX does not define the actual type of time_t.
2022-01-15 14:56:13 +05:30
struct timespec stop;
clock_gettime(CLOCK_MONOTONIC, &stop);
grid: add compile-time define to enable timing of the reflow operation
2021-05-11 17:43:17 +02:00
replace gettimeofday with clock_gettime POSIX.1-2008 has marked gettimeofday(2) as obsolete, recommending the use of clock_gettime(2) instead. CLOCK_MONOTONIC has been used instead of CLOCK_REALTIME because it is unaffected by manual changes in the system clock. This makes it better for our purposes, namely, measuring the difference between two points in time. tv_sec has been casted to long in most places since POSIX does not define the actual type of time_t.
2022-01-15 14:56:13 +05:30
struct timespec diff;
timespec_sub(&stop, &start, &diff);
LOG_INFO("reflowed %d -> %d rows in %lds %ldns",
grid: fix 32-bit compilation
2021-05-15 12:11:58 +02:00
old_rows, new_rows,
replace gettimeofday with clock_gettime POSIX.1-2008 has marked gettimeofday(2) as obsolete, recommending the use of clock_gettime(2) instead. CLOCK_MONOTONIC has been used instead of CLOCK_REALTIME because it is unaffected by manual changes in the system clock. This makes it better for our purposes, namely, measuring the difference between two points in time. tv_sec has been casted to long in most places since POSIX does not define the actual type of time_t.
2022-01-15 14:56:13 +05:30
(long)diff.tv_sec,
diff.tv_nsec);
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: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
static bool
ranges_match(const struct row_range *r1, const struct row_range *r2,
enum row_range_type type)
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
{
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
switch (type) {
case ROW_RANGE_URI:
/* TODO: also match URI? */
return r1->uri.id == r2->uri.id;
case ROW_RANGE_CURLY:
return r1->curly.style == r2->curly.style &&
r1->curly.color_src == r2->curly.color_src &&
r1->curly.color == r2->curly.color;
}
BUG("invalid range type");
return false;
}
static bool
grid: refactor: remove union range_data_for_insertion This union is identical to row_range_data, except the URI char pointer is const. Let's ignore that, and re-use row_range_data, casting the URI pointer when necessary. Also remove uri_range_insert() and curly_range_insert(), and use the generic version of range_insert() everywhere.
2024-06-25 10:26:07 +02:00
range_match_data(const struct row_range *r, const union row_range_data *data,
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
enum row_range_type type)
{
switch (type) {
case ROW_RANGE_URI:
return r->uri.id == data->uri.id;
case ROW_RANGE_CURLY:
return r->curly.style == data->curly.style &&
r->curly.color_src == data->curly.color_src &&
r->curly.color == data->curly.color;
}
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
BUG("invalid range type");
return false;
}
static void
grid_row_range_put(struct row_ranges *ranges, int col,
grid: refactor: remove union range_data_for_insertion This union is identical to row_range_data, except the URI char pointer is const. Let's ignore that, and re-use row_range_data, casting the URI pointer when necessary. Also remove uri_range_insert() and curly_range_insert(), and use the generic version of range_insert() everywhere.
2024-06-25 10:26:07 +02:00
const union row_range_data *data, enum row_range_type type)
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
{
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
size_t insert_idx = 0;
bool replace = false;
bool run_merge_pass = false;
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
for (int i = ranges->count - 1; i >= 0; i--) {
struct row_range *r = &ranges->v[i];
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
const bool matching = range_match_data(r, data, type);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
if (matching && r->end + 1 == col) {
/* Extend existing range tail */
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
r->end++;
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
return;
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
}
else if (r->end < col) {
insert_idx = i + 1;
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
break;
}
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
else if (r->start > col)
continue;
else {
xassert(r->start <= col);
xassert(r->end >= col);
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
if (matching)
return;
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
if (r->start == r->end) {
replace = true;
run_merge_pass = true;
insert_idx = i;
} else if (r->start == col) {
run_merge_pass = true;
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
r->start++;
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
insert_idx = i;
} else if (r->end == col) {
run_merge_pass = true;
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
r->end--;
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
insert_idx = i + 1;
} else {
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
xassert(r->start < col);
xassert(r->end > col);
grid: refactor: remove union range_data_for_insertion This union is identical to row_range_data, except the URI char pointer is const. Let's ignore that, and re-use row_range_data, casting the URI pointer when necessary. Also remove uri_range_insert() and curly_range_insert(), and use the generic version of range_insert() everywhere.
2024-06-25 10:26:07 +02:00
union row_range_data insert_data;
switch (type) {
case ROW_RANGE_URI: insert_data.uri = r->uri; break;
case ROW_RANGE_CURLY: insert_data.curly = r->curly; break;
}
range_insert(ranges, i + 1, col + 1, r->end, type, &insert_data);
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
grid: reload pointers into the uri range vector after inserting Inserting elements into the URI range vector typically triggers a vector resize. This is done using realloc(). Sometimes this causes the vector to move, thus invalidating all existing pointers into the vector.
2021-12-08 17:41:29 +01:00
/* The insertion may xrealloc() the vector, making our
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* 'old' pointer invalid */
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
r = &ranges->v[i];
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
r->end = col - 1;
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
xassert(r->start <= r->end);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
insert_idx = i + 1;
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
}
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
break;
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
}
}
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
xassert(insert_idx <= ranges->count);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
if (replace) {
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
grid_row_range_destroy(&ranges->v[insert_idx], type);
ranges->v[insert_idx] = (struct row_range){
grid: uri_range_{append,insert}: pass range attributes as separate parameters
2021-11-27 16:24:26 +01:00
.start = col,
.end = col,
};
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
switch (type) {
case ROW_RANGE_URI:
ranges->v[insert_idx].uri.id = data->uri.id;
ranges->v[insert_idx].uri.uri = xstrdup(data->uri.uri);
break;
case ROW_RANGE_CURLY:
ranges->v[insert_idx].curly = data->curly;
break;
}
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
} else
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
range_insert(ranges, insert_idx, col, col, type, data);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
if (run_merge_pass) {
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
for (size_t i = 1; i < ranges->count; i++) {
struct row_range *r1 = &ranges->v[i - 1];
struct row_range *r2 = &ranges->v[i];
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
if (ranges_match(r1, r2, type) && r1->end + 1 == r2->start) {
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
r1->end = r2->end;
grid: row_range_put(): use correct type in call to range_delete()
2024-06-25 20:01:47 +02:00
range_delete(ranges, type, i);
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
i--;
}
}
}
}
void
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id)
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
{
ensure_row_has_extra_data(row);
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
grid_row_range_put(
&row->extra->uri_ranges, col,
grid: refactor: remove union range_data_for_insertion This union is identical to row_range_data, except the URI char pointer is const. Let's ignore that, and re-use row_range_data, casting the URI pointer when necessary. Also remove uri_range_insert() and curly_range_insert(), and use the generic version of range_insert() everywhere.
2024-06-25 10:26:07 +02:00
&(union row_range_data){.uri = {.id = id, .uri = (char *)uri}},
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
ROW_RANGE_URI);
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
verify_no_overlapping_ranges(row->extra);
verify_ranges_are_sorted(row->extra);
}
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
void
grid_row_curly_range_put(struct row *row, int col, struct curly_range_data data)
{
ensure_row_has_extra_data(row);
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
grid_row_range_put(
&row->extra->curly_ranges, col,
grid: refactor: remove union range_data_for_insertion This union is identical to row_range_data, except the URI char pointer is const. Let's ignore that, and re-use row_range_data, casting the URI pointer when necessary. Also remove uri_range_insert() and curly_range_insert(), and use the generic version of range_insert() everywhere.
2024-06-25 10:26:07 +02:00
&(union row_range_data){.curly = data},
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
ROW_RANGE_CURLY);
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
grid: grid_row_{uri,curly}_range_put(): share code grid_row_uri_range_put() and grid_row_curly_range_put() now share the same base logic. Range specific data is passed through a union, and range specific checks are done through switched functions.
2024-06-25 09:55:55 +02:00
verify_no_overlapping_ranges(row->extra);
verify_ranges_are_sorted(row->extra);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
}
UNITTEST
{
struct row_data row_data = {.uri_ranges = {0}};
struct row row = {.extra = &row_data};
#define verify_range(idx, _start, _end, _id) \
do { \
xassert(idx < row_data.uri_ranges.count); \
xassert(row_data.uri_ranges.v[idx].start == _start); \
xassert(row_data.uri_ranges.v[idx].end == _end); \
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
xassert(row_data.uri_ranges.v[idx].uri.id == _id); \
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
} while (0)
grid_row_uri_range_put(&row, 0, "http://foo.bar", 123);
grid_row_uri_range_put(&row, 1, "http://foo.bar", 123);
grid_row_uri_range_put(&row, 2, "http://foo.bar", 123);
grid_row_uri_range_put(&row, 3, "http://foo.bar", 123);
xassert(row_data.uri_ranges.count == 1);
verify_range(0, 0, 3, 123);
/* No-op */
grid_row_uri_range_put(&row, 0, "http://foo.bar", 123);
xassert(row_data.uri_ranges.count == 1);
verify_range(0, 0, 3, 123);
/* Replace head */
grid_row_uri_range_put(&row, 0, "http://head", 456);
xassert(row_data.uri_ranges.count == 2);
verify_range(0, 0, 0, 456);
verify_range(1, 1, 3, 123);
/* Replace tail */
grid_row_uri_range_put(&row, 3, "http://tail", 789);
xassert(row_data.uri_ranges.count == 3);
verify_range(1, 1, 2, 123);
verify_range(2, 3, 3, 789);
/* Replace tail + extend head */
grid_row_uri_range_put(&row, 2, "http://tail", 789);
xassert(row_data.uri_ranges.count == 3);
verify_range(1, 1, 1, 123);
verify_range(2, 2, 3, 789);
/* Replace + extend tail */
grid_row_uri_range_put(&row, 1, "http://head", 456);
xassert(row_data.uri_ranges.count == 2);
verify_range(0, 0, 1, 456);
verify_range(1, 2, 3, 789);
/* Replace + extend, then splice */
grid_row_uri_range_put(&row, 1, "http://tail", 789);
grid_row_uri_range_put(&row, 2, "http://splice", 000);
xassert(row_data.uri_ranges.count == 4);
verify_range(0, 0, 0, 456);
verify_range(1, 1, 1, 789);
verify_range(2, 2, 2, 000);
verify_range(3, 3, 3, 789);
for (size_t i = 0; i < row_data.uri_ranges.count; i++)
grid_row_uri_range_destroy(&row_data.uri_ranges.v[i]);
free(row_data.uri_ranges.v);
#undef verify_range
osc8: update URI ranges as we print data, *not* when the URI is closed At first, an OSC-8 URI range was added when we received the closing OSC-8 escape (i.e. with an empty URI). But, this meant that cursor movements while the OSC-8 escape was in effect wasn’t handled correctly, since we’d add a range that spanned the cursor movements. Attempts were made to handle this in the cursor movement functions, by closing and re-opening the URI. However, there are too many corner cases to make this a viable approach. Scrolling is one such example, line-wrapping another. This patch takes a different approach; emit, or update the URI range when we print to the grid. This models the intended behavior much more closely, where an active OSC-8 URI act like any other SGR attribute - it is applied to all cells printed to, but otherwise have no effect. To avoid killing performance, this is only done in the “generic” printer. This means OSC-8 open/close calls must now “switch” the ASCII printer. Note that the “fast” printer still needs to *erase* pre-existing OSC-8 URIs. Closes #816
2021-11-25 19:22:52 +01:00
}
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
static void
grid_row_range_erase(struct row_ranges *ranges, enum row_range_type type,
int start, int end)
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
{
grid: refactor grid_row_uri_range_erase() The old algorithm always created a new URI, followed by (maybe) removing the existing URI, when an URI needed to be modified. That is, if e.g. the tail of an URI was being erased, the old algorithm would create a new URI for the part of the URI that should remain, and then removed the old URI. This isn’t very effective. The new algorithm instead identifies all possible overlap cases, and handles each one differently: * URI ends *before* erase range starts - continue with the next URI without further checks * URI starts *after* the erase range ends - return, we’re done * Erase range erases the entire URI - remove the URI * Erase range erases a part in the middle - split the URI * Erase range erases the head of the URI - adjust the URI’s start * Erase range erases the tail of the URI - adjust the URI’s end
2021-11-20 15:46:20 +01:00
xassert(start <= end);
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
/* Split up, or remove, URI ranges affected by the erase */
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
for (int i = ranges->count - 1; i >= 0; i--) {
struct row_range *old = &ranges->v[i];
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
grid: refactor grid_row_uri_range_erase() The old algorithm always created a new URI, followed by (maybe) removing the existing URI, when an URI needed to be modified. That is, if e.g. the tail of an URI was being erased, the old algorithm would create a new URI for the part of the URI that should remain, and then removed the old URI. This isn’t very effective. The new algorithm instead identifies all possible overlap cases, and handles each one differently: * URI ends *before* erase range starts - continue with the next URI without further checks * URI starts *after* the erase range ends - return, we’re done * Erase range erases the entire URI - remove the URI * Erase range erases a part in the middle - split the URI * Erase range erases the head of the URI - adjust the URI’s start * Erase range erases the tail of the URI - adjust the URI’s end
2021-11-20 15:46:20 +01:00
if (old->end < start)
grid: uri_range_erase: walk the ranges backwards This way, ranges are deleted last-to-first, thus avoiding memmoving multiple ranges over and over again when erasing e.g. a full line.
2021-11-28 10:56:32 +01:00
return;
grid: refactor grid_row_uri_range_erase() The old algorithm always created a new URI, followed by (maybe) removing the existing URI, when an URI needed to be modified. That is, if e.g. the tail of an URI was being erased, the old algorithm would create a new URI for the part of the URI that should remain, and then removed the old URI. This isn’t very effective. The new algorithm instead identifies all possible overlap cases, and handles each one differently: * URI ends *before* erase range starts - continue with the next URI without further checks * URI starts *after* the erase range ends - return, we’re done * Erase range erases the entire URI - remove the URI * Erase range erases a part in the middle - split the URI * Erase range erases the head of the URI - adjust the URI’s start * Erase range erases the tail of the URI - adjust the URI’s end
2021-11-20 15:46:20 +01:00
if (old->start > end)
grid: uri_range_erase: walk the ranges backwards This way, ranges are deleted last-to-first, thus avoiding memmoving multiple ranges over and over again when erasing e.g. a full line.
2021-11-28 10:56:32 +01:00
continue;
grid: refactor grid_row_uri_range_erase() The old algorithm always created a new URI, followed by (maybe) removing the existing URI, when an URI needed to be modified. That is, if e.g. the tail of an URI was being erased, the old algorithm would create a new URI for the part of the URI that should remain, and then removed the old URI. This isn’t very effective. The new algorithm instead identifies all possible overlap cases, and handles each one differently: * URI ends *before* erase range starts - continue with the next URI without further checks * URI starts *after* the erase range ends - return, we’re done * Erase range erases the entire URI - remove the URI * Erase range erases a part in the middle - split the URI * Erase range erases the head of the URI - adjust the URI’s start * Erase range erases the tail of the URI - adjust the URI’s end
2021-11-20 15:46:20 +01:00
if (start <= old->start && end >= old->end) {
/* Erase range covers URI completely - remove it */
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
range_delete(ranges, type, i);
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
}
grid: refactor grid_row_uri_range_erase() The old algorithm always created a new URI, followed by (maybe) removing the existing URI, when an URI needed to be modified. That is, if e.g. the tail of an URI was being erased, the old algorithm would create a new URI for the part of the URI that should remain, and then removed the old URI. This isn’t very effective. The new algorithm instead identifies all possible overlap cases, and handles each one differently: * URI ends *before* erase range starts - continue with the next URI without further checks * URI starts *after* the erase range ends - return, we’re done * Erase range erases the entire URI - remove the URI * Erase range erases a part in the middle - split the URI * Erase range erases the head of the URI - adjust the URI’s start * Erase range erases the tail of the URI - adjust the URI’s end
2021-11-20 15:46:20 +01:00
else if (start > old->start && end < old->end) {
grid: refactor: remove union range_data_for_insertion This union is identical to row_range_data, except the URI char pointer is const. Let's ignore that, and re-use row_range_data, casting the URI pointer when necessary. Also remove uri_range_insert() and curly_range_insert(), and use the generic version of range_insert() everywhere.
2024-06-25 10:26:07 +02:00
/*
* Erase range erases a part in the middle of the URI
*
* Must copy, since range_insert() may xrealloc() (thus
* causing 'old' to be invalid) before it dereferences
* old->data
*/
union row_range_data data = old->data;
range_insert(ranges, i + 1, end + 1, old->end, type, &data);
grid: reload pointers into the uri range vector after inserting Inserting elements into the URI range vector typically triggers a vector resize. This is done using realloc(). Sometimes this causes the vector to move, thus invalidating all existing pointers into the vector.
2021-12-08 17:41:29 +01:00
/* The insertion may xrealloc() the vector, making our
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* 'old' pointer invalid */
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
old = &ranges->v[i];
grid: refactor grid_row_uri_range_erase() The old algorithm always created a new URI, followed by (maybe) removing the existing URI, when an URI needed to be modified. That is, if e.g. the tail of an URI was being erased, the old algorithm would create a new URI for the part of the URI that should remain, and then removed the old URI. This isn’t very effective. The new algorithm instead identifies all possible overlap cases, and handles each one differently: * URI ends *before* erase range starts - continue with the next URI without further checks * URI starts *after* the erase range ends - return, we’re done * Erase range erases the entire URI - remove the URI * Erase range erases a part in the middle - split the URI * Erase range erases the head of the URI - adjust the URI’s start * Erase range erases the tail of the URI - adjust the URI’s end
2021-11-20 15:46:20 +01:00
old->end = start - 1;
return; /* There can be no more URIs affected by the erase range */
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
}
grid: refactor grid_row_uri_range_erase() The old algorithm always created a new URI, followed by (maybe) removing the existing URI, when an URI needed to be modified. That is, if e.g. the tail of an URI was being erased, the old algorithm would create a new URI for the part of the URI that should remain, and then removed the old URI. This isn’t very effective. The new algorithm instead identifies all possible overlap cases, and handles each one differently: * URI ends *before* erase range starts - continue with the next URI without further checks * URI starts *after* the erase range ends - return, we’re done * Erase range erases the entire URI - remove the URI * Erase range erases a part in the middle - split the URI * Erase range erases the head of the URI - adjust the URI’s start * Erase range erases the tail of the URI - adjust the URI’s end
2021-11-20 15:46:20 +01:00
else if (start <= old->start && end >= old->start) {
/* Erase range erases the head of the URI */
xassert(start <= old->start);
old->start = end + 1;
}
else if (start <= old->end && end >= old->end) {
/* Erase range erases the tail of the URI */
xassert(end >= old->end);
old->end = start - 1;
grid: uri_range_erase: walk the ranges backwards This way, ranges are deleted last-to-first, thus avoiding memmoving multiple ranges over and over again when erasing e.g. a full line.
2021-11-28 10:56:32 +01:00
return; /* There can be no more overlapping URIs */
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
}
}
}
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
void
grid_row_uri_range_erase(struct row *row, int start, int end)
{
xassert(row->extra != NULL);
grid_row_range_erase(&row->extra->uri_ranges, ROW_RANGE_URI, start, end);
}
void
grid_row_curly_range_erase(struct row *row, int start, int end)
{
xassert(row->extra != NULL);
grid_row_range_erase(&row->extra->curly_ranges, ROW_RANGE_CURLY, start, end);
}
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
UNITTEST
{
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
struct row_data row_data = {.uri_ranges = {0}};
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
struct row row = {.extra = &row_data};
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
const union row_range_data data = {
.uri = {
.id = 0,
.uri = (char *)"dummy",
},
};
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
grid: uri_range_erase(): unittest: try erasing a row without any URIs
2021-11-28 11:05:00 +01:00
/* Try erasing a row without any URIs */
grid_row_uri_range_erase(&row, 0, 200);
xassert(row_data.uri_ranges.count == 0);
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append(&row_data.uri_ranges, 1, 10, ROW_RANGE_URI, &data);
range_append(&row_data.uri_ranges, 11, 20, ROW_RANGE_URI, &data);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
xassert(row_data.uri_ranges.count == 2);
xassert(row_data.uri_ranges.v[1].start == 11);
xassert(row_data.uri_ranges.v[1].end == 20);
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
verify_no_overlapping_ranges(&row_data);
verify_ranges_are_sorted(&row_data);
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
/* Erase both URis */
grid_row_uri_range_erase(&row, 1, 20);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
xassert(row_data.uri_ranges.count == 0);
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
verify_no_overlapping_ranges(&row_data);
verify_ranges_are_sorted(&row_data);
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
/* Two URIs, then erase second half of the first, first half of
the second */
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append(&row_data.uri_ranges, 1, 10, ROW_RANGE_URI, &data);
range_append(&row_data.uri_ranges, 11, 20, ROW_RANGE_URI, &data);
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
grid_row_uri_range_erase(&row, 5, 15);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
xassert(row_data.uri_ranges.count == 2);
xassert(row_data.uri_ranges.v[0].start == 1);
xassert(row_data.uri_ranges.v[0].end == 4);
xassert(row_data.uri_ranges.v[1].start == 16);
xassert(row_data.uri_ranges.v[1].end == 20);
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
verify_no_overlapping_ranges(&row_data);
verify_ranges_are_sorted(&row_data);
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
grid_row_range_destroy(&row_data.uri_ranges.v[0], ROW_RANGE_URI);
grid_row_range_destroy(&row_data.uri_ranges.v[1], ROW_RANGE_URI);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
row_data.uri_ranges.count = 0;
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
/* One URI, erase middle part of it */
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append(&row_data.uri_ranges, 1, 10, ROW_RANGE_URI, &data);
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
grid_row_uri_range_erase(&row, 5, 6);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
xassert(row_data.uri_ranges.count == 2);
xassert(row_data.uri_ranges.v[0].start == 1);
xassert(row_data.uri_ranges.v[0].end == 4);
xassert(row_data.uri_ranges.v[1].start == 7);
xassert(row_data.uri_ranges.v[1].end == 10);
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
verify_no_overlapping_ranges(&row_data);
verify_ranges_are_sorted(&row_data);
grid: add grid_row_uri_range_erase() This function handles erasing of an URI range. That is, a range of the row is being either erased, or overwritten (from the URI perspective, these two are the same thing). We handle both partial overwrites (split up, or truncate URI), as well as complete overwrites (remove URI).
2021-11-20 13:42:07 +01:00
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
grid_row_range_destroy(&row_data.uri_ranges.v[0], ROW_RANGE_URI);
grid_row_range_destroy(&row_data.uri_ranges.v[1], ROW_RANGE_URI);
grid: reload pointers into the uri range vector after inserting Inserting elements into the URI range vector typically triggers a vector resize. This is done using realloc(). Sometimes this causes the vector to move, thus invalidating all existing pointers into the vector.
2021-12-08 17:41:29 +01:00
row_data.uri_ranges.count = 0;
/*
* Regression test: erasing the middle part of an URI causes us to
* insert a new URI (we split the partly erased URI into two).
*
* The insertion logic typically triggers an xrealloc(), which, in
* some cases, *moves* the entire URI vector to a new base
* address. grid_row_uri_range_erase() did not account for this,
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* and tried to update the 'end' member in the URI range we just
grid: reload pointers into the uri range vector after inserting Inserting elements into the URI range vector typically triggers a vector resize. This is done using realloc(). Sometimes this causes the vector to move, thus invalidating all existing pointers into the vector.
2021-12-08 17:41:29 +01:00
* split. This causes foot to crash when the xrealloc() has moved
* the URI range vector.
*
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
* (note: we're only verifying we don't crash here, hence the lack
grid: reload pointers into the uri range vector after inserting Inserting elements into the URI range vector typically triggers a vector resize. This is done using realloc(). Sometimes this causes the vector to move, thus invalidating all existing pointers into the vector.
2021-12-08 17:41:29 +01:00
* of assertions).
*/
free(row_data.uri_ranges.v);
row_data.uri_ranges.v = NULL;
row_data.uri_ranges.size = 0;
grid: refactor: replace {uri,curly}_range_append() with range_append() Also add range_append_by_ref(), with replaces uri_range_append_no_strdup().
2024-06-26 19:01:54 +02:00
range_append(&row_data.uri_ranges, 1, 10, ROW_RANGE_URI, &data);
grid: reload pointers into the uri range vector after inserting Inserting elements into the URI range vector typically triggers a vector resize. This is done using realloc(). Sometimes this causes the vector to move, thus invalidating all existing pointers into the vector.
2021-12-08 17:41:29 +01:00
xassert(row_data.uri_ranges.size == 1);
grid_row_uri_range_erase(&row, 5, 7);
xassert(row_data.uri_ranges.count == 2);
grid: refactor: first step towards a more generic range handling
2024-06-23 13:29:12 +02:00
grid_row_ranges_destroy(&row_data.uri_ranges, ROW_RANGE_URI);
osc8: uri ranges: use a dynamically re-sizable array instead of a tllist
2021-11-26 19:55:27 +01:00
free(row_data.uri_ranges.v);
grid: add new function grid_row_add_uri_range()
2021-02-14 20:50:33 +01:00
}
Reference in a new issue Copy permalink