circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2026-06-21 17:55:21 +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; 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 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) u_int *x, u_int *y)
{ {
if (wx < 0 || wy < 0) if (wx < 0 || wy < 0)
@@ -288,14 +288,14 @@ screen_redraw_window_scene(struct redraw_build_ctx *bctx, int wx, int wy,
return (1); return (1);
} }
/* Convert pane position to scene. */ /* Convert pane position to scene position. Return 0 if outside the scene. */
static int 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) struct window_pane *wp, int px, int py, u_int *x, u_int *y)
{ {
int wx = wp->xoff + px, wy = wp->yoff + py; 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. */ /* Convert redraw border mask to a cell type. */
@@ -304,33 +304,33 @@ screen_redraw_get_cell_type(int mask)
{ {
switch (mask) { switch (mask) {
case REDRAW_BORDER_L|REDRAW_BORDER_R|REDRAW_BORDER_U|REDRAW_BORDER_D: 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: 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: 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|REDRAW_BORDER_R:
case REDRAW_BORDER_L: case REDRAW_BORDER_L:
case REDRAW_BORDER_R: case REDRAW_BORDER_R:
return (CELL_LEFTRIGHT); return (CELL_LR);
case REDRAW_BORDER_L|REDRAW_BORDER_U|REDRAW_BORDER_D: case REDRAW_BORDER_L|REDRAW_BORDER_U|REDRAW_BORDER_D:
return (CELL_RIGHTJOIN); return (CELL_ULD);
case REDRAW_BORDER_L|REDRAW_BORDER_U: case REDRAW_BORDER_L|REDRAW_BORDER_U:
return (CELL_BOTTOMRIGHT); return (CELL_LU);
case REDRAW_BORDER_L|REDRAW_BORDER_D: case REDRAW_BORDER_L|REDRAW_BORDER_D:
return (CELL_TOPRIGHT); return (CELL_LD);
case REDRAW_BORDER_R|REDRAW_BORDER_U|REDRAW_BORDER_D: case REDRAW_BORDER_R|REDRAW_BORDER_U|REDRAW_BORDER_D:
return (CELL_LEFTJOIN); return (CELL_URD);
case REDRAW_BORDER_R|REDRAW_BORDER_U: case REDRAW_BORDER_R|REDRAW_BORDER_U:
return (CELL_BOTTOMLEFT); return (CELL_RU);
case REDRAW_BORDER_R|REDRAW_BORDER_D: case REDRAW_BORDER_R|REDRAW_BORDER_D:
return (CELL_TOPLEFT); return (CELL_RD);
case REDRAW_BORDER_U|REDRAW_BORDER_D: case REDRAW_BORDER_U|REDRAW_BORDER_D:
case REDRAW_BORDER_U: case REDRAW_BORDER_U:
case REDRAW_BORDER_D: 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. */ /* 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 (wy = top; wy <= bottom; wy++) {
for (wx = left; wx <= right; wx++) { 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); 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 (py = 0; py < wp->sy; py++) {
for (px = 0; px < wp->sx; px++) { 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; continue;
bc = screen_redraw_cell(bctx, x, y); bc = screen_redraw_cell(bctx, x, y);
memset(bc, 0, sizeof *bc); 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++) { for (sy = 0; sy < wp->sy; sy++) {
wy = wp->yoff + (int)sy; wy = wp->yoff + (int)sy;
for (wx = sx; wx <= ex; wx++) { 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; continue;
bc = screen_redraw_cell(bctx, x, y); bc = screen_redraw_cell(bctx, x, y);
memset(bc, 0, sizeof *bc); 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; enum pane_lines pane_lines;
u_int x, y; 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; return;
bc = screen_redraw_cell(bctx, x, y); bc = screen_redraw_cell(bctx, x, y);
@@ -521,7 +523,7 @@ screen_redraw_mark_border_status(struct redraw_build_ctx *bctx,
return; return;
for (wx = sx; wx <= ex; wx++, off++) { 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; continue;
bc = screen_redraw_cell(bctx, x, y); bc = screen_redraw_cell(bctx, x, y);
if (bc->data.type != REDRAW_SPAN_BORDER) 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; wx = wp->xoff + 1;
if (wx >= left && wx <= right) { if (wx >= left && wx <= right) {
wy = top; 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); bc = screen_redraw_cell(bctx, x, y);
if (bc->data.type == REDRAW_SPAN_BORDER) if (bc->data.type == REDRAW_SPAN_BORDER)
bc->data.b.flags |= REDRAW_BORDER_IS_ARROW; bc->data.b.flags |= REDRAW_BORDER_IS_ARROW;
} }
wy = bottom; 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); bc = screen_redraw_cell(bctx, x, y);
if (bc->data.type == REDRAW_SPAN_BORDER) if (bc->data.type == REDRAW_SPAN_BORDER)
bc->data.b.flags |= REDRAW_BORDER_IS_ARROW; 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; wy = wp->yoff + 1;
if (wy >= top && wy <= bottom) { if (wy >= top && wy <= bottom) {
wx = left; 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); bc = screen_redraw_cell(bctx, x, y);
if (bc->data.type == REDRAW_SPAN_BORDER) if (bc->data.type == REDRAW_SPAN_BORDER)
bc->data.b.flags |= REDRAW_BORDER_IS_ARROW; bc->data.b.flags |= REDRAW_BORDER_IS_ARROW;
} }
wx = right; 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); bc = screen_redraw_cell(bctx, x, y);
if (bc->data.type == REDRAW_SPAN_BORDER) if (bc->data.type == REDRAW_SPAN_BORDER)
bc->data.b.flags |= REDRAW_BORDER_IS_ARROW; 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 * Build and return a redraw scene for a client. The caller owns the scene and
* free it with screen_redraw_free_scene(). * must free it with screen_redraw_free_scene.
*/ */
static struct redraw_scene * static struct redraw_scene *
screen_redraw_make_scene(struct client *c) 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. */ /* Get style for cells without a pane. */
static void 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 grid_cell *gc)
{ {
struct redraw_scene *scene = dctx->scene; 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); 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 * 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 redraw_span *span)
{ {
struct window_pane *active = dctx->active; struct window_pane *active = dctx->active;
@@ -1083,15 +1088,15 @@ screen_redraw_draw_border_span(struct redraw_draw_ctx *dctx,
int isolates = 0; int isolates = 0;
if (span->data.type != REDRAW_SPAN_BORDER) if (span->data.type != REDRAW_SPAN_BORDER)
cell_type = CELL_OUTSIDE; cell_type = CELL_NONE;
else { 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; cell_type = span->data.b.cell_type;
} }
if (wp == NULL) { if (wp == NULL) {
pane_lines = options_get_number(oo, "pane-border-lines"); 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); window_get_border_cell(w, NULL, pane_lines, cell_type, &gc);
} else { } else {
window_pane_get_border_style(wp, c, &gc); 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; gc.attr ^= GRID_ATTR_REVERSE;
screen_redraw_draw_border_arrow(dctx, span, &gc); 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; isolates = 1;
tty_cursor(tty, x, y); tty_cursor(tty, x, y);
if (isolates) 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 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 redraw_span *span = *spanp;
struct window_pane *wp; struct window_pane *wp;
u_int start, end; u_int start, end;
if (span == NULL || span->data.type != REDRAW_SPAN_STATUS) if (span == NULL || span->data.type != REDRAW_SPAN_STATUS)
return (CELL_LEFTRIGHT); return (CELL_LR);
wp = span->data.st.wp; wp = span->data.st.wp;
for (; span != NULL; span = TAILQ_NEXT(span, entry)) { for (; span != NULL; span = TAILQ_NEXT(span, entry)) {
if (span->data.type != REDRAW_SPAN_STATUS) 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) if (span == NULL)
*spanp = NULL; *spanp = NULL;
return (CELL_LEFTRIGHT); return (CELL_LR);
} }
/* Draw screen. */ /* 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; gc.attr |= GRID_ATTR_CHARSET;
if (left) if (left)
screen_write_box_border_set(lines, CELL_LEFTJOIN, &gc); screen_write_box_border_set(lines, CELL_URD, &gc);
else 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_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++) for (i = 1; i < nx - 1; i++)
screen_write_cell(ctx, &gc); screen_write_cell(ctx, &gc);
if (right) if (right)
screen_write_box_border_set(lines, CELL_RIGHTJOIN, &gc); screen_write_box_border_set(lines, CELL_ULD, &gc);
else 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_cell(ctx, &gc);
screen_write_set_cursor(ctx, cx, cy); 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; gc.flags |= GRID_FLAG_NOPALETTE;
/* Draw top border */ /* 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_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++) for (i = 1; i < nx - 1; i++)
screen_write_cell(ctx, &gc); 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); screen_write_cell(ctx, &gc);
/* Draw bottom border */ /* Draw bottom border */
screen_write_set_cursor(ctx, cx, cy + ny - 1); 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_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++) for (i = 1; i < nx - 1; i++)
screen_write_cell(ctx, &gc); 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); screen_write_cell(ctx, &gc);
/* Draw sides */ /* 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++) { for (i = 1; i < ny - 1; i++) {
/* left side */ /* left side */
screen_write_set_cursor(ctx, cx, cy + i); 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_USED_ONLY 0x8
#define GRID_STRING_EMPTY_CELLS 0x10 #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_INSIDE 0
#define CELL_TOPBOTTOM 1 #define CELL_UD 1
#define CELL_LEFTRIGHT 2 #define CELL_LR 2
#define CELL_TOPLEFT 3 #define CELL_RD 3
#define CELL_TOPRIGHT 4 #define CELL_LD 4
#define CELL_BOTTOMLEFT 5 #define CELL_RU 5
#define CELL_BOTTOMRIGHT 6 #define CELL_LU 6
#define CELL_TOPJOIN 7 #define CELL_LRD 7
#define CELL_BOTTOMJOIN 8 #define CELL_LRU 8
#define CELL_LEFTJOIN 9 #define CELL_URD 9
#define CELL_RIGHTJOIN 10 #define CELL_ULD 10
#define CELL_JOIN 11 #define CELL_LRUD 11
#define CELL_OUTSIDE 12 #define CELL_NONE 12
#define CELL_SCROLLBAR 13 #define CELL_SCROLLBAR 13
/* Cell borders. */ /* 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_free_scene(struct redraw_scene *);
void screen_redraw_invalidate_scene(struct window *); void screen_redraw_invalidate_scene(struct window *);
void screen_redraw_invalidate_all_scenes(void); 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 */ /* screen.c */
void screen_init(struct screen *, u_int, u_int, u_int); 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; 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]); utf8_copy(&gc->data, &w->fill_character[0]);
return; return;
} }
switch (pane_lines) { switch (pane_lines) {
case PANE_LINES_NUMBER: case PANE_LINES_NUMBER:
if (cell_type == CELL_OUTSIDE) { if (cell_type == CELL_NONE) {
gc->attr |= GRID_ATTR_CHARSET; gc->attr |= GRID_ATTR_CHARSET;
utf8_set(&gc->data, CELL_BORDERS[CELL_OUTSIDE]); utf8_set(&gc->data, CELL_BORDERS[CELL_NONE]);
break; break;
} }
gc->attr &= ~GRID_ATTR_CHARSET; 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); window_pane_get_border_style(wp, c, &gc);
pane_lines = window_pane_get_pane_lines(wp); pane_lines = window_pane_get_pane_lines(wp);
for (i = 0; i < width; i++) { 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); window_get_border_cell(wp->window, wp, pane_lines, cell_type, &gc);
screen_write_cell(&ctx, &gc); screen_write_cell(&ctx, &gc);
} }