circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2026-06-20 17:25:57 +00:00
Code Issues Projects Releases Wiki Activity

Rename CELL_* and some other functions.

Browse Source
This commit is contained in:
Nicholas Marriott
2026-06-18 15:50:29 +01:00
parent c25270a7c3
commit 9288c7d0cb
4 changed files with 78 additions and 70 deletions
Download Patch File Download Diff File Expand all files Collapse all files

85
screen-redraw.c
View File

@@ -265,9 +265,9 @@ screen_redraw_reset_cell(struct redraw_build_ctx *bctx, u_int x, u_int y)
bc->data.type = REDRAW_SPAN_OUTSIDE;
}
/* Convert window position to scene position. */
/* Convert window position to scene position. Return 0 if outside the scene. */
static int
screen_redraw_window_scene(struct redraw_build_ctx *bctx, int wx, int wy,
screen_redraw_window_to_scene(struct redraw_build_ctx *bctx, int wx, int wy,
u_int *x, u_int *y)
{
if (wx < 0 || wy < 0)
@@ -288,14 +288,14 @@ screen_redraw_window_scene(struct redraw_build_ctx *bctx, int wx, int wy,
return (1);
}
/* Convert pane position to scene. */
/* Convert pane position to scene position. Return 0 if outside the scene. */
static int
screen_redraw_pane_scene(struct redraw_build_ctx *bctx,
screen_redraw_pane_to_scene(struct redraw_build_ctx *bctx,
struct window_pane *wp, int px, int py, u_int *x, u_int *y)
{
int wx = wp->xoff + px, wy = wp->yoff + py;
return (screen_redraw_window_scene(bctx, wx, wy, x, y));
return (screen_redraw_window_to_scene(bctx, wx, wy, x, y));
}
/* Convert redraw border mask to a cell type. */
@@ -304,33 +304,33 @@ screen_redraw_get_cell_type(int mask)
{
switch (mask) {
case REDRAW_BORDER_L|REDRAW_BORDER_R|REDRAW_BORDER_U|REDRAW_BORDER_D:
return (CELL_JOIN);
return (CELL_LRUD);
case REDRAW_BORDER_L|REDRAW_BORDER_R|REDRAW_BORDER_U:
return (CELL_BOTTOMJOIN);
return (CELL_LRU);
case REDRAW_BORDER_L|REDRAW_BORDER_R|REDRAW_BORDER_D:
return (CELL_TOPJOIN);
return (CELL_LRD);
case REDRAW_BORDER_L|REDRAW_BORDER_R:
case REDRAW_BORDER_L:
case REDRAW_BORDER_R:
return (CELL_LEFTRIGHT);
return (CELL_LR);
case REDRAW_BORDER_L|REDRAW_BORDER_U|REDRAW_BORDER_D:
return (CELL_RIGHTJOIN);
return (CELL_ULD);
case REDRAW_BORDER_L|REDRAW_BORDER_U:
return (CELL_BOTTOMRIGHT);
return (CELL_LU);
case REDRAW_BORDER_L|REDRAW_BORDER_D:
return (CELL_TOPRIGHT);
return (CELL_LD);
case REDRAW_BORDER_R|REDRAW_BORDER_U|REDRAW_BORDER_D:
return (CELL_LEFTJOIN);
return (CELL_URD);
case REDRAW_BORDER_R|REDRAW_BORDER_U:
return (CELL_BOTTOMLEFT);
return (CELL_RU);
case REDRAW_BORDER_R|REDRAW_BORDER_D:
return (CELL_TOPLEFT);
return (CELL_RD);
case REDRAW_BORDER_U|REDRAW_BORDER_D:
case REDRAW_BORDER_U:
case REDRAW_BORDER_D:
return (CELL_TOPBOTTOM);
return (CELL_UD);
}
return (CELL_OUTSIDE);
return (CELL_NONE);
}
/* Return if this cell has exactly two panes with a shared border. */
@@ -383,7 +383,7 @@ screen_redraw_reset_floating_pane_cells(struct redraw_build_ctx *bctx,
for (wy = top; wy <= bottom; wy++) {
for (wx = left; wx <= right; wx++) {
if (screen_redraw_window_scene(bctx, wx, wy, &x, &y))
if (screen_redraw_window_to_scene(bctx, wx, wy, &x, &y))
screen_redraw_reset_cell(bctx, x, y);
}
}
@@ -399,7 +399,8 @@ screen_redraw_mark_pane_inside(struct redraw_build_ctx *bctx,
for (py = 0; py < wp->sy; py++) {
for (px = 0; px < wp->sx; px++) {
if (!screen_redraw_pane_scene(bctx, wp, px, py, &x, &y))
if (!screen_redraw_pane_to_scene(bctx, wp, px, py, &x,
&y))
continue;
bc = screen_redraw_cell(bctx, x, y);
memset(bc, 0, sizeof *bc);
@@ -435,7 +436,8 @@ screen_redraw_mark_pane_scrollbar(struct redraw_build_ctx *bctx,
for (sy = 0; sy < wp->sy; sy++) {
wy = wp->yoff + (int)sy;
for (wx = sx; wx <= ex; wx++) {
if (!screen_redraw_window_scene(bctx, wx, wy, &x, &y))
if (!screen_redraw_window_to_scene(bctx, wx, wy, &x,
&y))
continue;
bc = screen_redraw_cell(bctx, x, y);
memset(bc, 0, sizeof *bc);
@@ -463,7 +465,7 @@ screen_redraw_mark_border_cell(struct redraw_build_ctx *bctx, int wx, int wy,
enum pane_lines pane_lines;
u_int x, y;
if (!screen_redraw_window_scene(bctx, wx, wy, &x, &y))
if (!screen_redraw_window_to_scene(bctx, wx, wy, &x, &y))
return;
bc = screen_redraw_cell(bctx, x, y);
@@ -521,7 +523,7 @@ screen_redraw_mark_border_status(struct redraw_build_ctx *bctx,
return;
for (wx = sx; wx <= ex; wx++, off++) {
if (!screen_redraw_window_scene(bctx, wx, wy, &x, &y))
if (!screen_redraw_window_to_scene(bctx, wx, wy, &x, &y))
continue;
bc = screen_redraw_cell(bctx, x, y);
if (bc->data.type != REDRAW_SPAN_BORDER)
@@ -550,13 +552,13 @@ screen_redraw_mark_border_arrows(struct redraw_build_ctx *bctx,
wx = wp->xoff + 1;
if (wx >= left && wx <= right) {
wy = top;
if (screen_redraw_window_scene(bctx, wx, wy, &x, &y)) {
if (screen_redraw_window_to_scene(bctx, wx, wy, &x, &y)) {
bc = screen_redraw_cell(bctx, x, y);
if (bc->data.type == REDRAW_SPAN_BORDER)
bc->data.b.flags |= REDRAW_BORDER_IS_ARROW;
}
wy = bottom;
if (screen_redraw_window_scene(bctx, wx, wy, &x, &y)) {
if (screen_redraw_window_to_scene(bctx, wx, wy, &x, &y)) {
bc = screen_redraw_cell(bctx, x, y);
if (bc->data.type == REDRAW_SPAN_BORDER)
bc->data.b.flags |= REDRAW_BORDER_IS_ARROW;
@@ -566,13 +568,13 @@ screen_redraw_mark_border_arrows(struct redraw_build_ctx *bctx,
wy = wp->yoff + 1;
if (wy >= top && wy <= bottom) {
wx = left;
if (screen_redraw_window_scene(bctx, wx, wy, &x, &y)) {
if (screen_redraw_window_to_scene(bctx, wx, wy, &x, &y)) {
bc = screen_redraw_cell(bctx, x, y);
if (bc->data.type == REDRAW_SPAN_BORDER)
bc->data.b.flags |= REDRAW_BORDER_IS_ARROW;
}
wx = right;
if (screen_redraw_window_scene(bctx, wx, wy, &x, &y)) {
if (screen_redraw_window_to_scene(bctx, wx, wy, &x, &y)) {
bc = screen_redraw_cell(bctx, x, y);
if (bc->data.type == REDRAW_SPAN_BORDER)
bc->data.b.flags |= REDRAW_BORDER_IS_ARROW;
@@ -822,10 +824,9 @@ screen_redraw_finish_scene(struct redraw_build_ctx *bctx,
}
}
/*
* Build and return a redraw scene for c. The caller owns the scene and must
* free it with screen_redraw_free_scene().
* Build and return a redraw scene for a client. The caller owns the scene and
* must free it with screen_redraw_free_scene.
*/
static struct redraw_scene *
screen_redraw_make_scene(struct client *c)
@@ -993,7 +994,7 @@ screen_redraw_draw_pane_span(struct redraw_draw_ctx *dctx,
/* Get style for cells without a pane. */
static void
screen_redraw_draw_get_default_style(struct redraw_draw_ctx *dctx,
screen_redraw_get_default_border_style(struct redraw_draw_ctx *dctx,
struct grid_cell *gc)
{
struct redraw_scene *scene = dctx->scene;
@@ -1012,9 +1013,13 @@ screen_redraw_draw_get_default_style(struct redraw_draw_ctx *dctx,
memcpy(gc, dgc, sizeof *gc);
}
/* Find pane to use for this span. */
/*
* For this border span, pick the pane whose border style should colour it.
* Prefer an explicitly assigned style owner, then the active adjacent pane,
* then any adjacent pane.
*/
static struct window_pane *
screen_redraw_draw_get_style_pane(struct redraw_draw_ctx *dctx,
screen_redraw_get_pane_for_border_style(struct redraw_draw_ctx *dctx,
struct redraw_span *span)
{
struct window_pane *active = dctx->active;
@@ -1083,15 +1088,15 @@ screen_redraw_draw_border_span(struct redraw_draw_ctx *dctx,
int isolates = 0;
if (span->data.type != REDRAW_SPAN_BORDER)
cell_type = CELL_OUTSIDE;
cell_type = CELL_NONE;
else {
wp = screen_redraw_draw_get_style_pane(dctx, span);
wp = screen_redraw_get_pane_for_border_style(dctx, span);
cell_type = span->data.b.cell_type;
}
if (wp == NULL) {
pane_lines = options_get_number(oo, "pane-border-lines");
screen_redraw_draw_get_default_style(dctx, &gc);
screen_redraw_get_default_border_style(dctx, &gc);
window_get_border_cell(w, NULL, pane_lines, cell_type, &gc);
} else {
window_pane_get_border_style(wp, c, &gc);
@@ -1104,7 +1109,7 @@ screen_redraw_draw_border_span(struct redraw_draw_ctx *dctx,
gc.attr ^= GRID_ATTR_REVERSE;
screen_redraw_draw_border_arrow(dctx, span, &gc);
if (cell_type == CELL_TOPBOTTOM && (dctx->flags & REDRAW_ISOLATES))
if (cell_type == CELL_UD && (dctx->flags & REDRAW_ISOLATES))
isolates = 1;
tty_cursor(tty, x, y);
if (isolates)
@@ -1547,16 +1552,16 @@ screen_redraw_draw(struct client *c, struct window_pane *wp, int flags)
}
/* Get cell type for offset from span. */
/* Get border cell type beneath status cell at offset x in pane status line. */
int
screen_redraw_get_span_cell_type(struct redraw_span **spanp, u_int x)
screen_redraw_get_status_border_cell_type(struct redraw_span **spanp, u_int x)
{
struct redraw_span *span = *spanp;
struct window_pane *wp;
u_int start, end;
if (span == NULL || span->data.type != REDRAW_SPAN_STATUS)
return (CELL_LEFTRIGHT);
return (CELL_LR);
wp = span->data.st.wp;
for (; span != NULL; span = TAILQ_NEXT(span, entry)) {
if (span->data.type != REDRAW_SPAN_STATUS)
@@ -1578,7 +1583,7 @@ screen_redraw_get_span_cell_type(struct redraw_span **spanp, u_int x)
}
if (span == NULL)
*spanp = NULL;
return (CELL_LEFTRIGHT);
return (CELL_LR);
}
/* Draw screen. */

24
screen-write.c
View File

@@ -728,19 +728,19 @@ screen_write_hline(struct screen_write_ctx *ctx, u_int nx, int left, int right,
gc.attr |= GRID_ATTR_CHARSET;
if (left)
screen_write_box_border_set(lines, CELL_LEFTJOIN, &gc);
screen_write_box_border_set(lines, CELL_URD, &gc);
else
screen_write_box_border_set(lines, CELL_LEFTRIGHT, &gc);
screen_write_box_border_set(lines, CELL_LR, &gc);
screen_write_cell(ctx, &gc);
screen_write_box_border_set(lines, CELL_LEFTRIGHT, &gc);
screen_write_box_border_set(lines, CELL_LR, &gc);
for (i = 1; i < nx - 1; i++)
screen_write_cell(ctx, &gc);
if (right)
screen_write_box_border_set(lines, CELL_RIGHTJOIN, &gc);
screen_write_box_border_set(lines, CELL_ULD, &gc);
else
screen_write_box_border_set(lines, CELL_LEFTRIGHT, &gc);
screen_write_box_border_set(lines, CELL_LR, &gc);
screen_write_cell(ctx, &gc);
screen_write_set_cursor(ctx, cx, cy);
@@ -843,26 +843,26 @@ screen_write_box(struct screen_write_ctx *ctx, u_int nx, u_int ny,
gc.flags |= GRID_FLAG_NOPALETTE;
/* Draw top border */
screen_write_box_border_set(lines, CELL_TOPLEFT, &gc);
screen_write_box_border_set(lines, CELL_RD, &gc);
screen_write_cell(ctx, &gc);
screen_write_box_border_set(lines, CELL_LEFTRIGHT, &gc);
screen_write_box_border_set(lines, CELL_LR, &gc);
for (i = 1; i < nx - 1; i++)
screen_write_cell(ctx, &gc);
screen_write_box_border_set(lines, CELL_TOPRIGHT, &gc);
screen_write_box_border_set(lines, CELL_LD, &gc);
screen_write_cell(ctx, &gc);
/* Draw bottom border */
screen_write_set_cursor(ctx, cx, cy + ny - 1);
screen_write_box_border_set(lines, CELL_BOTTOMLEFT, &gc);
screen_write_box_border_set(lines, CELL_RU, &gc);
screen_write_cell(ctx, &gc);
screen_write_box_border_set(lines, CELL_LEFTRIGHT, &gc);
screen_write_box_border_set(lines, CELL_LR, &gc);
for (i = 1; i < nx - 1; i++)
screen_write_cell(ctx, &gc);
screen_write_box_border_set(lines, CELL_BOTTOMRIGHT, &gc);
screen_write_box_border_set(lines, CELL_LU, &gc);
screen_write_cell(ctx, &gc);
/* Draw sides */
screen_write_box_border_set(lines, CELL_TOPBOTTOM, &gc);
screen_write_box_border_set(lines, CELL_UD, &gc);
for (i = 1; i < ny - 1; i++) {
/* left side */
screen_write_set_cursor(ctx, cx, cy + i);

31
tmux.h
View File

@@ -798,20 +798,23 @@ struct colour_palette {
#define GRID_STRING_USED_ONLY 0x8
#define GRID_STRING_EMPTY_CELLS 0x10
/* Cell positions. */
/*
* Cell border characters. Border cells are named for the directions they
* connect to: U for up, D for down, L for left and R for right.
*/
#define CELL_INSIDE 0
#define CELL_TOPBOTTOM 1
#define CELL_LEFTRIGHT 2
#define CELL_TOPLEFT 3
#define CELL_TOPRIGHT 4
#define CELL_BOTTOMLEFT 5
#define CELL_BOTTOMRIGHT 6
#define CELL_TOPJOIN 7
#define CELL_BOTTOMJOIN 8
#define CELL_LEFTJOIN 9
#define CELL_RIGHTJOIN 10
#define CELL_JOIN 11
#define CELL_OUTSIDE 12
#define CELL_UD 1
#define CELL_LR 2
#define CELL_RD 3
#define CELL_LD 4
#define CELL_RU 5
#define CELL_LU 6
#define CELL_LRD 7
#define CELL_LRU 8
#define CELL_URD 9
#define CELL_ULD 10
#define CELL_LRUD 11
#define CELL_NONE 12
#define CELL_SCROLLBAR 13
/* Cell borders. */
@@ -3370,7 +3373,7 @@ void screen_redraw_pane_scrollbar(struct client *, struct window_pane *);
void screen_redraw_free_scene(struct redraw_scene *);
void screen_redraw_invalidate_scene(struct window *);
void screen_redraw_invalidate_all_scenes(void);
int screen_redraw_get_span_cell_type(struct redraw_span **, u_int);
int screen_redraw_get_status_border_cell_type(struct redraw_span **, u_int);
/* screen.c */
void screen_init(struct screen *, u_int, u_int, u_int);

8
window-border.c
View File

@@ -29,16 +29,16 @@ window_get_border_cell(struct window *w, struct window_pane *wp,
{
u_int idx;
if (cell_type == CELL_OUTSIDE && w->fill_character != NULL) {
if (cell_type == CELL_NONE && w->fill_character != NULL) {
utf8_copy(&gc->data, &w->fill_character[0]);
return;
}
switch (pane_lines) {
case PANE_LINES_NUMBER:
if (cell_type == CELL_OUTSIDE) {
if (cell_type == CELL_NONE) {
gc->attr |= GRID_ATTR_CHARSET;
utf8_set(&gc->data, CELL_BORDERS[CELL_OUTSIDE]);
utf8_set(&gc->data, CELL_BORDERS[CELL_NONE]);
break;
}
gc->attr &= ~GRID_ATTR_CHARSET;
@@ -145,7 +145,7 @@ window_make_pane_status(struct window_pane *wp, struct client *c, u_int width,
window_pane_get_border_style(wp, c, &gc);
pane_lines = window_pane_get_pane_lines(wp);
for (i = 0; i < width; i++) {
cell_type = screen_redraw_get_span_cell_type(&span, i);
cell_type = screen_redraw_get_status_border_cell_type(&span, i);
window_get_border_cell(wp->window, wp, pane_lines, cell_type, &gc);
screen_write_cell(&ctx, &gc);
}