From 674a535fc3e1260762aaecb37af4a32581d9b0c6 Mon Sep 17 00:00:00 2001 From: Craig Barnes Date: Mon, 1 Jul 2024 20:00:16 +0100 Subject: [PATCH] Rename various uses of "curly" in the source code with "underline" 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. --- csi.c | 48 +++++++++--------- dcs.c | 14 +++--- grid.c | 144 ++++++++++++++++++++++++++--------------------------- grid.h | 14 +++--- render.c | 62 +++++++++++------------ terminal.c | 24 ++++----- terminal.h | 32 ++++++------ 7 files changed, 169 insertions(+), 169 deletions(-) diff --git a/csi.c b/csi.c index 10f525ef..04a15973 100644 --- a/csi.c +++ b/csi.c @@ -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; diff --git a/dcs.c b/dcs.c index 7856d79c..6a832aed 100644 --- a/dcs.c +++ b/dcs.c @@ -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( diff --git a/grid.c b/grid.c index 1db71b5c..2f65a1dd 100644 --- a/grid.c +++ b/grid.c @@ -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 diff --git a/grid.h b/grid.h index c5c2b60c..de8f98ab 100644 --- a/grid.h +++ b/grid.h @@ -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; diff --git a/render.c b/render.c index 1853eb48..37e7a80f 100644 --- a/render.c +++ b/render.c @@ -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; diff --git a/terminal.c b/terminal.c index 83cbb42b..0518e57d 100644 --- a/terminal.c +++ b/terminal.c @@ -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); } } diff --git a/terminal.h b/terminal.h index 21eb7cee..a148e528 100644 --- a/terminal.h +++ b/terminal.h @@ -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; };