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

Rename various uses of "curly" in the source code with "underline"

Browse source 
Since "curly" could make it seem as if all underline styles are curled
(to people unfamiliar with the codebase), whereas in reality only 1 is.
This commit is contained in:
Craig Barnes 2024-07-01 20:00:16 +01:00
parent 64e7f25124
commit 674a535fc3
7 changed files with 169 additions and 169 deletions
Download patch file Download diff file Expand all files Collapse all files

48
csi.c
View file

@ -33,10 +33,10 @@ static void
sgr_reset(struct terminal *term)
{
term->vt.attrs = (struct attributes){0};
term->vt.curly = (struct curly_range_data){0};
term->vt.underline = (struct underline_range_data){0};
term->bits_affecting_ascii_printer.curly_style = false;
term->bits_affecting_ascii_printer.curly_color = false;
term->bits_affecting_ascii_printer.underline_style = false;
term->bits_affecting_ascii_printer.underline_color = false;
term_update_ascii_printer(term);
}
@ -95,27 +95,27 @@ csi_sgr(struct terminal *term)
case 3: term->vt.attrs.italic = true; break;
case 4: {
term->vt.attrs.underline = true;
term->vt.curly.style = CURLY_SINGLE;
term->vt.underline.style = UNDERLINE_SINGLE;
if (unlikely(term->vt.params.v[i].sub.idx == 1)) {
enum curly_style style = term->vt.params.v[i].sub.value[0];
enum underline_style style = term->vt.params.v[i].sub.value[0];
switch (style) {
default:
case CURLY_NONE:
case UNDERLINE_NONE:
term->vt.attrs.underline = false;
term->vt.curly.style = CURLY_NONE;
term->bits_affecting_ascii_printer.curly_style = false;
term->vt.underline.style = UNDERLINE_NONE;
term->bits_affecting_ascii_printer.underline_style = false;
break;
case CURLY_SINGLE:
case CURLY_DOUBLE:
case CURLY_CURLY:
case CURLY_DOTTED:
case CURLY_DASHED:
term->vt.curly.style = style;
term->bits_affecting_ascii_printer.curly_style =
style > CURLY_SINGLE;
case UNDERLINE_SINGLE:
case UNDERLINE_DOUBLE:
case UNDERLINE_CURLY:
case UNDERLINE_DOTTED:
case UNDERLINE_DASHED:
term->vt.underline.style = style;
term->bits_affecting_ascii_printer.underline_style =
style > UNDERLINE_SINGLE;
break;
}
@ -134,8 +134,8 @@ csi_sgr(struct terminal *term)
case 23: term->vt.attrs.italic = false; break;
case 24: {
term->vt.attrs.underline = false;
term->vt.curly.style = CURLY_NONE;
term->bits_affecting_ascii_printer.curly_style = false;
term->vt.underline.style = UNDERLINE_NONE;
term->bits_affecting_ascii_printer.underline_style = false;
term_update_ascii_printer(term);
break;
}
@ -236,9 +236,9 @@ csi_sgr(struct terminal *term)
}
if (unlikely(param == 58)) {
term->vt.curly.color_src = src;
term->vt.curly.color = color;
term->bits_affecting_ascii_printer.curly_color = true;
term->vt.underline.color_src = src;
term->vt.underline.color = color;
term->bits_affecting_ascii_printer.underline_color = true;
term_update_ascii_printer(term);
} else if (param == 38) {
term->vt.attrs.fg_src = src;
@ -273,9 +273,9 @@ csi_sgr(struct terminal *term)
break;
case 59:
term->vt.curly.color_src = COLOR_DEFAULT;
term->vt.curly.color = 0;
term->bits_affecting_ascii_printer.curly_color = false;
term->vt.underline.color_src = COLOR_DEFAULT;
term->vt.underline.color = 0;
term->bits_affecting_ascii_printer.underline_color = false;
term_update_ascii_printer(term);
break;

14
dcs.c
View file

@ -298,10 +298,10 @@ decrqss_unhook(struct terminal *term)
if (a->italic)
append_sgr_attr("3");
if (a->underline) {
if (term->vt.curly.style > CURLY_SINGLE) {
if (term->vt.underline.style > UNDERLINE_SINGLE) {
char value[4];
int val_len =
xsnprintf(value, sizeof(value), "4:%d", term->vt.curly.style);
xsnprintf(value, sizeof(value), "4:%d", term->vt.underline.style);
append_sgr_attr_n(&reply, &len, value, val_len);
} else
append_sgr_attr("4");
@ -381,7 +381,7 @@ decrqss_unhook(struct terminal *term)
}
}
switch (term->vt.curly.color_src) {
switch (term->vt.underline.color_src) {
case COLOR_DEFAULT:
case COLOR_BASE16:
break;
@ -389,15 +389,15 @@ decrqss_unhook(struct terminal *term)
case COLOR_BASE256: {
char value[16];
int val_len = xsnprintf(
value, sizeof(value), "58:5:%u", term->vt.curly.color);
value, sizeof(value), "58:5:%u", term->vt.underline.color);
append_sgr_attr_n(&reply, &len, value, val_len);
break;
}
case COLOR_RGB: {
uint8_t r = term->vt.curly.color >> 16;
uint8_t g = term->vt.curly.color >> 8;
uint8_t b = term->vt.curly.color >> 0;
uint8_t r = term->vt.underline.color >> 16;
uint8_t g = term->vt.underline.color >> 8;
uint8_t b = term->vt.underline.color >> 0;
char value[32];
int val_len = xsnprintf(

144
grid.c
View file

@ -106,8 +106,8 @@ verify_no_overlapping_ranges_of_type(const struct row_ranges *ranges,
r2->uri.uri, r2->start, r2->end);
break;
case ROW_RANGE_CURLY:
BUG("curly underline overlap: %d-%d, %d-%d",
case ROW_RANGE_UNDERLINE:
BUG("underline overlap: %d-%d, %d-%d",
r1->start, r1->end, r2->start, r2->end);
break;
}
@ -121,7 +121,7 @@ static void
verify_no_overlapping_ranges(const struct row_data *extra)
{
verify_no_overlapping_ranges_of_type(&extra->uri_ranges, ROW_RANGE_URI);
verify_no_overlapping_ranges_of_type(&extra->curly_ranges, ROW_RANGE_CURLY);
verify_no_overlapping_ranges_of_type(&extra->underline_ranges, ROW_RANGE_UNDERLINE);
}
static void
@ -144,8 +144,8 @@ verify_ranges_of_type_are_sorted(const struct row_ranges *ranges,
r->uri.uri, r->start, r->end);
break;
case ROW_RANGE_CURLY:
BUG("curly ranges not sorted correctly: "
case ROW_RANGE_UNDERLINE:
BUG("underline ranges not sorted correctly: "
"%d-%d came before %d-%d",
last->start, last->end, r->start, r->end);
break;
@ -162,7 +162,7 @@ static void
verify_ranges_are_sorted(const struct row_data *extra)
{
verify_ranges_of_type_are_sorted(&extra->uri_ranges, ROW_RANGE_URI);
verify_ranges_of_type_are_sorted(&extra->curly_ranges, ROW_RANGE_CURLY);
verify_ranges_of_type_are_sorted(&extra->underline_ranges, ROW_RANGE_UNDERLINE);
}
static void
@ -205,8 +205,8 @@ range_insert(struct row_ranges *ranges, size_t idx, int start, int end,
r->uri.uri = xstrdup(data->uri.uri);
break;
case ROW_RANGE_CURLY:
r->curly = data->curly;
case ROW_RANGE_UNDERLINE:
r->underline = data->underline;
break;
}
}
@ -228,8 +228,8 @@ range_append_by_ref(struct row_ranges *ranges, int start, int end,
r->uri.uri = data->uri.uri;
break;
case ROW_RANGE_CURLY:
r->curly = data->curly;
case ROW_RANGE_UNDERLINE:
r->underline = data->underline;
break;
}
}
@ -246,7 +246,7 @@ range_append(struct row_ranges *ranges, int start, int end,
.uri = xstrdup(data->uri.uri)}});
break;
case ROW_RANGE_CURLY:
case ROW_RANGE_UNDERLINE:
range_append_by_ref(ranges, start, end, type, data);
break;
}
@ -307,7 +307,7 @@ grid_snapshot(const struct grid *grid)
clone_row->extra = clone_extra;
range_ensure_size(&clone_extra->uri_ranges, extra->uri_ranges.count);
range_ensure_size(&clone_extra->curly_ranges, extra->curly_ranges.count);
range_ensure_size(&clone_extra->underline_ranges, extra->underline_ranges.count);
for (int i = 0; i < extra->uri_ranges.count; i++) {
const struct row_range *range = &extra->uri_ranges.v[i];
@ -316,11 +316,11 @@ grid_snapshot(const struct grid *grid)
range->start, range->end, ROW_RANGE_URI, &range->data);
}
for (int i = 0; i < extra->curly_ranges.count; i++) {
const struct row_range *range = &extra->curly_ranges.v[i];
for (int i = 0; i < extra->underline_ranges.count; i++) {
const struct row_range *range = &extra->underline_ranges.v[i];
range_append_by_ref(
&clone_extra->curly_ranges, range->start, range->end,
ROW_RANGE_CURLY, &range->data);
&clone_extra->underline_ranges, range->start, range->end,
ROW_RANGE_UNDERLINE, &range->data);
}
} else
clone_row->extra = NULL;
@ -536,7 +536,7 @@ grid_resize_without_reflow(
struct row_data *new_extra = new_row->extra;
range_ensure_size(&new_extra->uri_ranges, old_extra->uri_ranges.count);
range_ensure_size(&new_extra->curly_ranges, old_extra->curly_ranges.count);
range_ensure_size(&new_extra->underline_ranges, old_extra->underline_ranges.count);
for (int i = 0; i < old_extra->uri_ranges.count; i++) {
const struct row_range *range = &old_extra->uri_ranges.v[i];
@ -551,8 +551,8 @@ grid_resize_without_reflow(
range_append(&new_extra->uri_ranges, start, end, ROW_RANGE_URI, &range->data);
}
for (int i = 0; i < old_extra->curly_ranges.count; i++) {
const struct row_range *range = &old_extra->curly_ranges.v[i];
for (int i = 0; i < old_extra->underline_ranges.count; i++) {
const struct row_range *range = &old_extra->underline_ranges.v[i];
if (range->start >= new_cols) {
/* The whole range is truncated */
@ -561,7 +561,7 @@ grid_resize_without_reflow(
const int start = range->start;
const int end = min(range->end, new_cols - 1);
range_append_by_ref(&new_extra->curly_ranges, start, end, ROW_RANGE_CURLY, &range->data);
range_append_by_ref(&new_extra->underline_ranges, start, end, ROW_RANGE_UNDERLINE, &range->data);
}
}
@ -642,7 +642,7 @@ reflow_range_start(struct row_range *range, enum row_range_type type,
struct row_ranges *new_ranges = NULL;
switch (type) {
case ROW_RANGE_URI: new_ranges = &new_row->extra->uri_ranges; break;
case ROW_RANGE_CURLY: new_ranges = &new_row->extra->curly_ranges; break;
case ROW_RANGE_UNDERLINE: new_ranges = &new_row->extra->underline_ranges; break;
}
if (new_ranges == NULL)
@ -652,7 +652,7 @@ reflow_range_start(struct row_range *range, enum row_range_type type,
switch (type) {
case ROW_RANGE_URI: range->uri.uri = NULL; break; /* Owned by new_ranges */
case ROW_RANGE_CURLY: break;
case ROW_RANGE_UNDERLINE: break;
}
}
@ -665,7 +665,7 @@ reflow_range_end(struct row_range *range, enum row_range_type type,
switch (type) {
case ROW_RANGE_URI: ranges = &extra->uri_ranges; break;
case ROW_RANGE_CURLY: ranges = &extra->curly_ranges; break;
case ROW_RANGE_UNDERLINE: ranges = &extra->underline_ranges; break;
}
if (ranges == NULL)
@ -681,10 +681,10 @@ reflow_range_end(struct row_range *range, enum row_range_type type,
xassert(new_range->uri.id == range->uri.id);
break;
case ROW_RANGE_CURLY:
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);
case ROW_RANGE_UNDERLINE:
xassert(new_range->underline.style == range->underline.style);
xassert(new_range->underline.color_src == range->underline.color_src);
xassert(new_range->underline.color == range->underline.color);
break;
}
@ -752,9 +752,9 @@ _line_wrap(struct grid *old_grid, struct row **new_grid, struct row *row,
}
}
if (extra->curly_ranges.count > 0) {
if (extra->underline_ranges.count > 0) {
struct row_range *range =
&extra->curly_ranges.v[extra->curly_ranges.count - 1];
&extra->underline_ranges.v[extra->underline_ranges.count - 1];
if (range->end < 0) {
@ -763,8 +763,8 @@ _line_wrap(struct grid *old_grid, struct row **new_grid, struct row *row,
/* Open a new range on the new/current row */
ensure_row_has_extra_data(new_row);
range_append(&new_row->extra->curly_ranges, 0, -1,
ROW_RANGE_CURLY, &range->data);
range_append(&new_row->extra->underline_ranges, 0, -1,
ROW_RANGE_UNDERLINE, &range->data);
}
}
@ -953,7 +953,7 @@ grid_resize_and_reflow(
/* Does this row have any URIs? */
struct row_range *uri_range, *uri_range_terminator;
struct row_range *curly_range, *curly_range_terminator;
struct row_range *underline_range, *underline_range_terminator;
struct row_data *extra = old_row->extra;
if (extra != NULL && extra->uri_ranges.count > 0) {
@ -968,21 +968,21 @@ grid_resize_and_reflow(
} else
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];
if (extra != NULL && extra->underline_ranges.count > 0) {
underline_range = &extra->underline_ranges.v[0];
underline_range_terminator = &extra->underline_ranges.v[extra->underline_ranges.count];
const struct row_range *last_on_row =
&extra->curly_ranges.v[extra->curly_ranges.count - 1];
&extra->underline_ranges.v[extra->underline_ranges.count - 1];
col_count = max(col_count, last_on_row->end + 1);
} else
curly_range = curly_range_terminator = NULL;
underline_range = underline_range_terminator = NULL;
for (int start = 0, left = col_count; left > 0;) {
int end;
bool tp_break = false;
bool uri_break = false;
bool curly_break = false;
bool underline_break = false;
bool ftcs_break = false;
/* Figure out where to end this chunk */
@ -990,8 +990,8 @@ grid_resize_and_reflow(
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)
const int underline_col = underline_range != underline_range_terminator
? ((underline_range->start >= start ? underline_range->start : underline_range->end) + 1)
: INT_MAX;
const int tp_col = tp != NULL ? tp->col + 1 : INT_MAX;
const int ftcs_col = old_row->shell_integration.cmd_start >= start
@ -1000,10 +1000,10 @@ grid_resize_and_reflow(
? old_row->shell_integration.cmd_end + 1
: INT_MAX;
end = min(col_count, min(min(tp_col, min(uri_col, curly_col)), ftcs_col));
end = min(col_count, min(min(tp_col, min(uri_col, underline_col)), ftcs_col));
uri_break = end == uri_col;
curly_break = end == curly_col;
underline_break = end == underline_col;
tp_break = end == tp_col;
ftcs_break = end == ftcs_col;
}
@ -1128,18 +1128,18 @@ grid_resize_and_reflow(
}
}
if (curly_break) {
xassert(curly_range != NULL);
if (underline_break) {
xassert(underline_range != NULL);
if (curly_range->start == end - 1)
if (underline_range->start == end - 1)
reflow_range_start(
curly_range, ROW_RANGE_CURLY, new_row, new_col_idx - 1);
underline_range, ROW_RANGE_UNDERLINE, new_row, new_col_idx - 1);
if (curly_range->end == end - 1) {
if (underline_range->end == end - 1) {
reflow_range_end(
curly_range, ROW_RANGE_CURLY, new_row, new_col_idx - 1);
grid_row_curly_range_destroy(curly_range);
curly_range++;
underline_range, ROW_RANGE_UNDERLINE, new_row, new_col_idx - 1);
grid_row_underline_range_destroy(underline_range);
underline_range++;
}
}
@ -1180,9 +1180,9 @@ grid_resize_and_reflow(
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);
if (new_row->extra->underline_ranges.count > 0) {
int last_idx = new_row->extra->underline_ranges.count - 1;
xassert(new_row->extra->underline_ranges.v[last_idx].end >= 0);
}
}
@ -1216,8 +1216,8 @@ grid_resize_and_reflow(
for (size_t i = 0; i < row->extra->uri_ranges.count; i++)
xassert(row->extra->uri_ranges.v[i].end >= 0);
for (size_t i = 0; i < row->extra->curly_ranges.count; i++)
xassert(row->extra->curly_ranges.v[i].end >= 0);
for (size_t i = 0; i < row->extra->underline_ranges.count; i++)
xassert(row->extra->underline_ranges.v[i].end >= 0);
verify_no_overlapping_ranges(row->extra);
verify_ranges_are_sorted(row->extra);
@ -1310,10 +1310,10 @@ ranges_match(const struct row_range *r1, const struct row_range *r2,
/* 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;
case ROW_RANGE_UNDERLINE:
return r1->underline.style == r2->underline.style &&
r1->underline.color_src == r2->underline.color_src &&
r1->underline.color == r2->underline.color;
}
BUG("invalid range type");
@ -1328,10 +1328,10 @@ range_match_data(const struct row_range *r, const union row_range_data *data,
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;
case ROW_RANGE_UNDERLINE:
return r->underline.style == data->underline.style &&
r->underline.color_src == data->underline.color_src &&
r->underline.color == data->underline.color;
}
BUG("invalid range type");
@ -1391,7 +1391,7 @@ grid_row_range_put(struct row_ranges *ranges, int col,
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;
case ROW_RANGE_UNDERLINE: insert_data.underline = r->underline; break;
}
range_insert(ranges, i + 1, col + 1, r->end, type, &insert_data);
@ -1424,8 +1424,8 @@ grid_row_range_put(struct row_ranges *ranges, int col,
ranges->v[insert_idx].uri.uri = xstrdup(data->uri.uri);
break;
case ROW_RANGE_CURLY:
ranges->v[insert_idx].curly = data->curly;
case ROW_RANGE_UNDERLINE:
ranges->v[insert_idx].underline = data->underline;
break;
}
} else
@ -1460,14 +1460,14 @@ grid_row_uri_range_put(struct row *row, int col, const char *uri, uint64_t id)
}
void
grid_row_curly_range_put(struct row *row, int col, struct curly_range_data data)
grid_row_underline_range_put(struct row *row, int col, struct underline_range_data data)
{
ensure_row_has_extra_data(row);
grid_row_range_put(
&row->extra->curly_ranges, col,
&(union row_range_data){.curly = data},
ROW_RANGE_CURLY);
&row->extra->underline_ranges, col,
&(union row_range_data){.underline = data},
ROW_RANGE_UNDERLINE);
verify_no_overlapping_ranges(row->extra);
verify_ranges_are_sorted(row->extra);
@ -1600,10 +1600,10 @@ grid_row_uri_range_erase(struct row *row, int start, int end)
}
void
grid_row_curly_range_erase(struct row *row, int start, int end)
grid_row_underline_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_row_range_erase(&row->extra->underline_ranges, ROW_RANGE_UNDERLINE, start, end);
}
UNITTEST

14
grid.h
View file

@ -88,9 +88,9 @@ void grid_row_uri_range_put(
struct row *row, int col, const char *uri, uint64_t id);
void grid_row_uri_range_erase(struct row *row, int start, int end);
void grid_row_curly_range_put(
struct row *row, int col, struct curly_range_data data);
void grid_row_curly_range_erase(struct row *row, int start, int end);
void grid_row_underline_range_put(
struct row *row, int col, struct underline_range_data data);
void grid_row_underline_range_erase(struct row *row, int start, int end);
static inline void
grid_row_uri_range_destroy(struct row_range *range)
@ -99,7 +99,7 @@ grid_row_uri_range_destroy(struct row_range *range)
}
static inline void
grid_row_curly_range_destroy(struct row_range *range)
grid_row_underline_range_destroy(struct row_range *range)
{
}
@ -108,7 +108,7 @@ grid_row_range_destroy(struct row_range *range, enum row_range_type type)
{
switch (type) {
case ROW_RANGE_URI: grid_row_uri_range_destroy(range); break;
case ROW_RANGE_CURLY: grid_row_curly_range_destroy(range); break;
case ROW_RANGE_UNDERLINE: grid_row_underline_range_destroy(range); break;
}
}
@ -129,9 +129,9 @@ grid_row_reset_extra(struct row *row)
return;
grid_row_ranges_destroy(&extra->uri_ranges, ROW_RANGE_URI);
grid_row_ranges_destroy(&extra->curly_ranges, ROW_RANGE_CURLY);
grid_row_ranges_destroy(&extra->underline_ranges, ROW_RANGE_UNDERLINE);
free(extra->uri_ranges.v);
free(extra->curly_ranges.v);
free(extra->underline_ranges.v);
free(extra);
row->extra = NULL;

62
render.c
View file

@ -388,11 +388,11 @@ static void
draw_styled_underline(const struct terminal *term, pixman_image_t *pix,
const struct fcft_font *font,
const pixman_color_t *color,
enum curly_style style, int x, int y, int cols)
enum underline_style style, int x, int y, int cols)
{
xassert(style != CURLY_NONE);
xassert(style != UNDERLINE_NONE);
if (style == CURLY_SINGLE) {
if (style == UNDERLINE_SINGLE) {
draw_underline(term, pix, font, color, x, y, cols);
return;
}
@ -406,20 +406,20 @@ draw_styled_underline(const struct terminal *term, pixman_image_t *pix,
/* Make sure the line isn't positioned below the cell */
switch (style) {
case CURLY_DOUBLE:
case CURLY_CURLY:
case UNDERLINE_DOUBLE:
case UNDERLINE_CURLY:
y_ofs = min(underline_offset(term, font),
term->cell_height - thickness * 3);
break;
case CURLY_DASHED:
case CURLY_DOTTED:
case UNDERLINE_DASHED:
case UNDERLINE_DOTTED:
y_ofs = min(underline_offset(term, font),
term->cell_height - thickness);
break;
case CURLY_NONE:
case CURLY_SINGLE:
case UNDERLINE_NONE:
case UNDERLINE_SINGLE:
BUG("underline styles not supposed to be handled here");
break;
}
@ -427,7 +427,7 @@ draw_styled_underline(const struct terminal *term, pixman_image_t *pix,
const int ceil_w = cols * term->cell_width;
switch (style) {
case CURLY_DOUBLE: {
case UNDERLINE_DOUBLE: {
const pixman_rectangle16_t rects[] = {
{x, y + y_ofs, ceil_w, thickness},
{x, y + y_ofs + thickness * 2, ceil_w, thickness}};
@ -435,7 +435,7 @@ draw_styled_underline(const struct terminal *term, pixman_image_t *pix,
break;
}
case CURLY_DASHED: {
case UNDERLINE_DASHED: {
const int ceil_w = cols * term->cell_width;
const int dash_w = ceil_w / 3 + (ceil_w % 3 > 0);
const pixman_rectangle16_t rects[] = {
@ -447,7 +447,7 @@ draw_styled_underline(const struct terminal *term, pixman_image_t *pix,
break;
}
case CURLY_DOTTED: {
case UNDERLINE_DOTTED: {
/* Number of dots per cell */
int per_cell = (term->cell_width / thickness) / 2;
if (per_cell == 0)
@ -486,7 +486,7 @@ draw_styled_underline(const struct terminal *term, pixman_image_t *pix,
break;
}
case CURLY_CURLY: {
case UNDERLINE_CURLY: {
const int top = y + y_ofs;
const int bot = top + thickness * 3;
const int half_x = x + ceil_w / 2.0, full_x = x + ceil_w;
@ -532,8 +532,8 @@ draw_styled_underline(const struct terminal *term, pixman_image_t *pix,
break;
}
case CURLY_NONE:
case CURLY_SINGLE:
case UNDERLINE_NONE:
case UNDERLINE_SINGLE:
BUG("underline styles not supposed to be handled here");
break;
}
@ -1005,27 +1005,27 @@ render_cell(struct terminal *term, pixman_image_t *pix, pixman_region32_t *damag
/* Underline */
if (cell->attrs.underline) {
pixman_color_t underline_color = fg;
enum curly_style underline_style = CURLY_SINGLE;
enum underline_style underline_style = UNDERLINE_SINGLE;
/* Check if cell has a styled underline. This lookup is fairly
expensive... */
if (row->extra != NULL) {
for (int i = 0; i < row->extra->curly_ranges.count; i++) {
const struct row_range *range = &row->extra->curly_ranges.v[i];
for (int i = 0; i < row->extra->underline_ranges.count; i++) {
const struct row_range *range = &row->extra->underline_ranges.v[i];
if (range->start > col)
break;
if (range->start <= col && col <= range->end) {
switch (range->curly.color_src) {
switch (range->underline.color_src) {
case COLOR_BASE256:
underline_color = color_hex_to_pixman(
term->colors.table[range->curly.color]);
term->colors.table[range->underline.color]);
break;
case COLOR_RGB:
underline_color =
color_hex_to_pixman(range->curly.color);
color_hex_to_pixman(range->underline.color);
break;
case COLOR_DEFAULT:
@ -1036,7 +1036,7 @@ render_cell(struct terminal *term, pixman_image_t *pix, pixman_region32_t *damag
break;
}
underline_style = range->curly.style;
underline_style = range->underline.style;
break;
}
}
@ -4442,27 +4442,27 @@ render_resize(struct terminal *term, int width, int height, uint8_t opts)
g.num_cols * sizeof(g.rows[i]->cells[0]));
if (orig->rows[j]->extra == NULL ||
orig->rows[j]->extra->curly_ranges.count == 0)
orig->rows[j]->extra->underline_ranges.count == 0)
{
continue;
}
/*
* Copy undercurly ranges
* Copy underline ranges
*/
const struct row_ranges *curly_src = &orig->rows[j]->extra->curly_ranges;
const struct row_ranges *underline_src = &orig->rows[j]->extra->underline_ranges;
const int count = curly_src->count;
const int count = underline_src->count;
g.rows[i]->extra = xcalloc(1, sizeof(*g.rows[i]->extra));
g.rows[i]->extra->curly_ranges.v = xmalloc(
count * sizeof(g.rows[i]->extra->curly_ranges.v[0]));
g.rows[i]->extra->underline_ranges.v = xmalloc(
count * sizeof(g.rows[i]->extra->underline_ranges.v[0]));
struct row_ranges *curly_dst = &g.rows[i]->extra->curly_ranges;
curly_dst->count = curly_dst->size = count;
struct row_ranges *underline_dst = &g.rows[i]->extra->underline_ranges;
underline_dst->count = underline_dst->size = count;
for (int k = 0; k < count; k++)
curly_dst->v[k] = curly_src->v[k];
underline_dst->v[k] = underline_src->v[k];
}
term->normal = g;

24
terminal.c
View file

@ -1942,7 +1942,7 @@ erase_cell_range(struct terminal *term, struct row *row, int start, int end)
if (unlikely(row->extra != NULL)) {
grid_row_uri_range_erase(row, start, end);
grid_row_curly_range_erase(row, start, end);
grid_row_underline_range_erase(row, start, end);
}
}
@ -3642,10 +3642,10 @@ term_fill(struct terminal *term, int r, int c, uint8_t data, size_t count,
}
if (unlikely(use_sgr_attrs &&
(term->vt.curly.style > CURLY_SINGLE ||
term->vt.curly.color_src != COLOR_DEFAULT)))
(term->vt.underline.style > UNDERLINE_SINGLE ||
term->vt.underline.color_src != COLOR_DEFAULT)))
{
grid_row_curly_range_put(row, c, term->vt.curly);
grid_row_underline_range_put(row, c, term->vt.underline);
}
}
@ -3653,12 +3653,12 @@ term_fill(struct terminal *term, int r, int c, uint8_t data, size_t count,
if (likely(term->vt.osc8.uri != NULL))
grid_row_uri_range_erase(row, c, c + count - 1);
if (likely(term->vt.curly.style <= CURLY_SINGLE &&
term->vt.curly.color_src == COLOR_DEFAULT))
if (likely(term->vt.underline.style <= UNDERLINE_SINGLE &&
term->vt.underline.color_src == COLOR_DEFAULT))
{
/* No extended/styled underlines active, so erase any such
attributes at the target columns */
grid_row_curly_range_erase(row, c, c + count - 1);
grid_row_underline_range_erase(row, c, c + count - 1);
}
}
}
@ -3730,12 +3730,12 @@ term_print(struct terminal *term, char32_t wc, int width)
} else if (row->extra != NULL)
grid_row_uri_range_erase(row, col, col + width - 1);
if (unlikely(term->vt.curly.style > CURLY_SINGLE ||
term->vt.curly.color_src != COLOR_DEFAULT))
if (unlikely(term->vt.underline.style > UNDERLINE_SINGLE ||
term->vt.underline.color_src != COLOR_DEFAULT))
{
grid_row_curly_range_put(row, col, term->vt.curly);
grid_row_underline_range_put(row, col, term->vt.underline);
} else if (row->extra != NULL)
grid_row_curly_range_erase(row, col, col + width - 1);
grid_row_underline_range_erase(row, col, col + width - 1);
/* Advance cursor the 'additional' columns while dirty:ing the cells */
for (int i = 1; i < width && (col + 1) < term->cols; i++) {
@ -3796,7 +3796,7 @@ ascii_printer_fast(struct terminal *term, char32_t wc)
if (unlikely(row->extra != NULL)) {
grid_row_uri_range_erase(row, uri_start, uri_start);
grid_row_curly_range_erase(row, uri_start, uri_start);
grid_row_underline_range_erase(row, uri_start, uri_start);
}
}

32
terminal.h
View file

@ -104,24 +104,24 @@ struct uri_range_data {
char *uri;
};
enum curly_style {
CURLY_NONE,
CURLY_SINGLE, /* Legacy underline */
CURLY_DOUBLE,
CURLY_CURLY,
CURLY_DOTTED,
CURLY_DASHED,
enum underline_style {
UNDERLINE_NONE,
UNDERLINE_SINGLE, /* Legacy underline */
UNDERLINE_DOUBLE,
UNDERLINE_CURLY,
UNDERLINE_DOTTED,
UNDERLINE_DASHED,
};
struct curly_range_data {
enum curly_style style;
struct underline_range_data {
enum underline_style style;
enum color_source color_src;
uint32_t color;
};
union row_range_data {
struct uri_range_data uri;
struct curly_range_data curly;
struct underline_range_data underline;
};
struct row_range {
@ -134,7 +134,7 @@ struct row_range {
* but can instead do range->uri.id */
union {
struct uri_range_data uri;
struct curly_range_data curly;
struct underline_range_data underline;
};
union row_range_data data;
};
@ -146,11 +146,11 @@ struct row_ranges {
int count;
};
enum row_range_type {ROW_RANGE_URI, ROW_RANGE_CURLY};
enum row_range_type {ROW_RANGE_URI, ROW_RANGE_UNDERLINE};
struct row_data {
struct row_ranges uri_ranges;
struct row_ranges curly_ranges;
struct row_ranges underline_ranges;
};
struct row {
@ -299,7 +299,7 @@ struct vt {
char *uri;
} osc8;
struct curly_range_data curly;
struct underline_range_data underline;
struct {
uint8_t *data;
@ -403,8 +403,8 @@ struct terminal {
struct {
bool sixels:1;
bool osc8:1;
bool curly_style:1;
bool curly_color:1;
bool underline_style:1;
bool underline_color:1;
bool insert_mode:1;
bool charset:1;
};