circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2025-01-12 03:08:46 +00:00
Code Issues Projects Releases Wiki Activity

Merge branch 'obsd-master'

Browse Source
This commit is contained in:
Thomas Adam 2020-10-05 12:01:23 +01:00
commit f5b7ebc540
6 changed files with 198 additions and 220 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

375
resize.c
View File

@ -92,130 +92,156 @@ ignore_client_size(struct client *c)
return (0);
}
void
default_window_size(struct client *c, struct session *s, struct window *w,
u_int *sx, u_int *sy, u_int *xpixel, u_int *ypixel, int type)
static u_int
clients_with_window(struct window *w)
{
struct client *loop;
u_int cx, cy, n;
const char *value;
u_int n = 0;
if (type == -1)
type = options_get_number(global_w_options, "window-size");
switch (type) {
case WINDOW_SIZE_LARGEST:
TAILQ_FOREACH(loop, &clients, entry) {
if (ignore_client_size(loop) || !session_has(loop->session, w))
continue;
if (++n > 1)
break;
}
return (n);
}
static int
clients_calculate_size(int type, int current, struct session *s,
struct window *w, int (*skip_client)(struct client *, int, int,
struct session *, struct window *), u_int *sx, u_int *sy, u_int *xpixel,
u_int *ypixel)
{
struct client *loop;
u_int cx, cy, n = 0;
/* Manual windows do not have their size changed based on a client. */
if (type == WINDOW_SIZE_MANUAL)
return (0);
/*
* Start comparing with 0 for largest and UINT_MAX for smallest or
* latest.
*/
if (type == WINDOW_SIZE_LARGEST)
*sx = *sy = 0;
*xpixel = *ypixel = 0;
TAILQ_FOREACH(loop, &clients, entry) {
if (ignore_client_size(loop))
continue;
if (w != NULL && !session_has(loop->session, w))
continue;
if (w == NULL && loop->session != s)
continue;
else
*sx = *sy = UINT_MAX;
*xpixel = *ypixel = 0;
cx = loop->tty.sx;
cy = loop->tty.sy - status_line_size(loop);
/*
* For latest, count the number of clients with this window. We only
* care if there is more than one.
*/
if (type == WINDOW_SIZE_LATEST)
n = clients_with_window(w);
/* Loop over the clients and work out the size. */
TAILQ_FOREACH(loop, &clients, entry) {
if (ignore_client_size(loop))
continue;
if (skip_client(loop, type, current, s, w))
continue;
/*
* If there are multiple clients attached, only accept the
* latest client; otherwise let the only client be chosen as
* for smallest.
*/
if (type == WINDOW_SIZE_LATEST && n > 1 && loop != w->latest)
continue;
/* Work out this client's size. */
cx = loop->tty.sx;
cy = loop->tty.sy - status_line_size(loop);
/*
* If it is larger or smaller than the best so far, update the
* new size.
*/
if (type == WINDOW_SIZE_LARGEST) {
if (cx > *sx)
*sx = cx;
if (cy > *sy)
*sy = cy;
if (loop->tty.xpixel > *xpixel &&
loop->tty.ypixel > *ypixel) {
*xpixel = loop->tty.xpixel;
*ypixel = loop->tty.ypixel;
}
}
if (*sx == 0 || *sy == 0)
goto manual;
break;
case WINDOW_SIZE_SMALLEST:
*sx = *sy = UINT_MAX;
*xpixel = *ypixel = 0;
TAILQ_FOREACH(loop, &clients, entry) {
if (ignore_client_size(loop))
continue;
if (w != NULL && !session_has(loop->session, w))
continue;
if (w == NULL && loop->session != s)
continue;
cx = loop->tty.sx;
cy = loop->tty.sy - status_line_size(loop);
} else {
if (cx < *sx)
*sx = cx;
if (cy < *sy)
*sy = cy;
if (loop->tty.xpixel > *xpixel &&
loop->tty.ypixel > *ypixel) {
*xpixel = loop->tty.xpixel;
*ypixel = loop->tty.ypixel;
}
}
if (*sx == UINT_MAX || *sy == UINT_MAX)
goto manual;
break;
case WINDOW_SIZE_LATEST:
if (loop->tty.xpixel > *xpixel && loop->tty.ypixel > *ypixel) {
*xpixel = loop->tty.xpixel;
*ypixel = loop->tty.ypixel;
}
}
/* Return whether a suitable size was found. */
if (type == WINDOW_SIZE_LARGEST)
return (*sx != 0 && *sy != 0);
return (*sx != UINT_MAX && *sy != UINT_MAX);
}
static int
default_window_size_skip_client (struct client *loop, int type,
__unused int current, struct session *s, struct window *w)
{
/*
* Latest checks separately, so do not check here. Otherwise only
* include clients where the session contains the window or where the
* session is the given session.
*/
if (type == WINDOW_SIZE_LATEST)
return (0);
if (w != NULL && !session_has(loop->session, w))
return (1);
if (w == NULL && loop->session != s)
return (1);
return (0);
}
void
default_window_size(struct client *c, struct session *s, struct window *w,
u_int *sx, u_int *sy, u_int *xpixel, u_int *ypixel, int type)
{
const char *value;
/* Get type if not provided. */
if (type == -1)
type = options_get_number(global_w_options, "window-size");
/*
* Latest clients can use the given client if suitable. If there is no
* client and no window, use the default size as for manual type.
*/
if (type == WINDOW_SIZE_LATEST) {
if (c != NULL && !ignore_client_size(c)) {
*sx = c->tty.sx;
*sy = c->tty.sy - status_line_size(c);
*xpixel = c->tty.xpixel;
*ypixel = c->tty.ypixel;
} else {
if (w == NULL)
goto manual;
n = 0;
TAILQ_FOREACH(loop, &clients, entry) {
if (!ignore_client_size(loop) &&
session_has(loop->session, w)) {
if (++n > 1)
break;
}
}
*sx = *sy = UINT_MAX;
*xpixel = *ypixel = 0;
TAILQ_FOREACH(loop, &clients, entry) {
if (ignore_client_size(loop))
continue;
if (n > 1 && loop != w->latest)
continue;
s = loop->session;
cx = loop->tty.sx;
cy = loop->tty.sy - status_line_size(loop);
if (cx < *sx)
*sx = cx;
if (cy < *sy)
*sy = cy;
if (loop->tty.xpixel > *xpixel &&
loop->tty.ypixel > *ypixel) {
*xpixel = loop->tty.xpixel;
*ypixel = loop->tty.ypixel;
}
}
if (*sx == UINT_MAX || *sy == UINT_MAX)
goto manual;
*ypixel = c->tty.ypixel;
goto done;
}
break;
case WINDOW_SIZE_MANUAL:
goto manual;
if (w == NULL)
type = WINDOW_SIZE_MANUAL;
}
goto done;
manual:
value = options_get_string(s->options, "default-size");
if (sscanf(value, "%ux%u", sx, sy) != 2) {
*sx = 80;
*sy = 24;
/*
* Look for a client to base the size on. If none exists (or the type
* is manual), use the default-size option.
*/
if (!clients_calculate_size(type, 0, s, w,
default_window_size_skip_client, sx, sy, xpixel, ypixel)) {
value = options_get_string(s->options, "default-size");
if (sscanf(value, "%ux%u", sx, sy) != 2) {
*sx = 80;
*sy = 24;
}
}
done:
/* Make sure the limits are enforced. */
if (*sx < WINDOW_MINIMUM)
*sx = WINDOW_MINIMUM;
if (*sx > WINDOW_MAXIMUM)
@ -226,127 +252,50 @@ done:
*sy = WINDOW_MAXIMUM;
}
static int
recalculate_size_skip_client(struct client *loop, __unused int type,
int current, __unused struct session *s, struct window *w)
{
/*
* If the current flag is set, then skip any client where this window
* is not the current window - this is used for aggressive-resize.
* Otherwise skip any session that doesn't contain the window.
*/
if (current)
return (loop->session->curw->window != w);
return (session_has(loop->session, w) == 0);
}
void
recalculate_size(struct window *w, int now)
{
struct session *s;
struct client *c;
u_int sx, sy, cx, cy, xpixel = 0, ypixel = 0, n;
int type, current, has, changed;
u_int sx, sy, xpixel = 0, ypixel = 0;
int type, current, changed;
/*
* Do not attempt to resize windows which have no pane, they must be on
* the way to destruction.
*/
if (w->active == NULL)
return;
log_debug("%s: @%u is %u,%u", __func__, w->id, w->sx, w->sy);
/*
* Type is manual, smallest, largest, latest. Current is the
* aggressive-resize option (do not resize based on clients where the
* window is not the current window).
*/
type = options_get_number(w->options, "window-size");
current = options_get_number(w->options, "aggressive-resize");
changed = 1;
switch (type) {
case WINDOW_SIZE_LARGEST:
sx = sy = 0;
TAILQ_FOREACH(c, &clients, entry) {
if (ignore_client_size(c))
continue;
s = c->session;
/* Look for a suitable client and get the new size. */
changed = clients_calculate_size(type, current, NULL, w,
recalculate_size_skip_client, &sx, &sy, &xpixel, &ypixel);
if (current)
has = (s->curw->window == w);
else
has = session_has(s, w);
if (!has)
continue;
cx = c->tty.sx;
cy = c->tty.sy - status_line_size(c);
if (cx > sx)
sx = cx;
if (cy > sy)
sy = cy;
if (c->tty.xpixel > xpixel && c->tty.ypixel > ypixel) {
xpixel = c->tty.xpixel;
ypixel = c->tty.ypixel;
}
}
if (sx == 0 || sy == 0)
changed = 0;
break;
case WINDOW_SIZE_SMALLEST:
sx = sy = UINT_MAX;
TAILQ_FOREACH(c, &clients, entry) {
if (ignore_client_size(c))
continue;
s = c->session;
if (current)
has = (s->curw->window == w);
else
has = session_has(s, w);
if (!has)
continue;
cx = c->tty.sx;
cy = c->tty.sy - status_line_size(c);
if (cx < sx)
sx = cx;
if (cy < sy)
sy = cy;
if (c->tty.xpixel > xpixel && c->tty.ypixel > ypixel) {
xpixel = c->tty.xpixel;
ypixel = c->tty.ypixel;
}
}
if (sx == UINT_MAX || sy == UINT_MAX)
changed = 0;
break;
case WINDOW_SIZE_LATEST:
n = 0;
TAILQ_FOREACH(c, &clients, entry) {
if (!ignore_client_size(c) &&
session_has(c->session, w)) {
if (++n > 1)
break;
}
}
sx = sy = UINT_MAX;
TAILQ_FOREACH(c, &clients, entry) {
if (ignore_client_size(c))
continue;
if (n > 1 && c != w->latest)
continue;
s = c->session;
if (current)
has = (s->curw->window == w);
else
has = session_has(s, w);
if (!has)
continue;
cx = c->tty.sx;
cy = c->tty.sy - status_line_size(c);
if (cx < sx)
sx = cx;
if (cy < sy)
sy = cy;
if (c->tty.xpixel > xpixel && c->tty.ypixel > ypixel) {
xpixel = c->tty.xpixel;
ypixel = c->tty.ypixel;
}
}
if (sx == UINT_MAX || sy == UINT_MAX)
changed = 0;
break;
case WINDOW_SIZE_MANUAL:
changed = 0;
break;
}
/*
* Make sure the size has actually changed. If the window has already
* got a resize scheduled, then use the new size; otherwise the old.
*/
if (w->flags & WINDOW_RESIZE) {
if (!now && changed && w->new_sx == sx && w->new_sy == sy)
changed = 0;
@ -355,10 +304,20 @@ recalculate_size(struct window *w, int now)
changed = 0;
}
/*
* If the size hasn't changed, update the window offset but not the
* size.
*/
if (!changed) {
tty_update_window_offset(w);
return;
}
/*
* If the now flag is set or if the window is sized manually, change
* the size immediately. Otherwise set the flag and it will be done
* later.
*/
log_debug("%s: @%u new size %u,%u", __func__, w->id, sx, sy);
if (now || type == WINDOW_SIZE_MANUAL)
resize_window(w, sx, sy, xpixel, ypixel);

4
tmux.1
View File

@ -5897,8 +5897,8 @@ Set a styled underscore.
The single parameter is one of: 0 for no underscore, 1 for normal
underscore, 2 for double underscore, 3 for curly underscore, 4 for dotted
underscore and 5 for dashed underscore.
.It Em \&Setulc
Set the underscore colour.
.It Em \&Setulc , \&ol
Set the underscore colour or reset to the default.
The argument is (red * 65536) + (green * 256) + blue where each is between 0
and 255.
.It Em \&Ss , Se

2
tmux.h
View File

@ -450,6 +450,7 @@ enum tty_code_code {
TTYC_KUP6,
TTYC_KUP7,
TTYC_MS,
TTYC_OL,
TTYC_OP,
TTYC_REV,
TTYC_RGB,
@ -461,6 +462,7 @@ enum tty_code_code {
TTYC_SE,
TTYC_SETAB,
TTYC_SETAF,
TTYC_SETAL,
TTYC_SETRGBB,
TTYC_SETRGBF,
TTYC_SETULC,

3
tty-features.c
View File

@ -112,6 +112,7 @@ static const struct tty_feature tty_feature_overline = {
static const char *tty_feature_usstyle_capabilities[] = {
"Smulx=\\E[4::%p1%dm",
"Setulc=\\E[58::2::%p1%{65536}%/%d::%p1%{256}%/%{255}%&%d::%p1%{255}%&%d%;m",
"ol=\\E[59m",
NULL
};
static const struct tty_feature tty_feature_usstyle = {
@ -336,7 +337,7 @@ tty_default_features(int *feat, const char *name, u_int version)
"256,RGB,bpaste,clipboard,strikethrough,title"
{ .name = "mintty",
.features = TTY_FEATURES_BASE_MODERN_XTERM
",ccolour,cstyle,extkeys,margins,overline"
",ccolour,cstyle,extkeys,margins,overline,usstyle"
},
{ .name = "tmux",
.features = TTY_FEATURES_BASE_MODERN_XTERM

2
tty-term.c
View File

@ -248,6 +248,7 @@ static const struct tty_term_code_entry tty_term_codes[] = {
[TTYC_KUP6] = { TTYCODE_STRING, "kUP6" },
[TTYC_KUP7] = { TTYCODE_STRING, "kUP7" },
[TTYC_MS] = { TTYCODE_STRING, "Ms" },
[TTYC_OL] = { TTYCODE_STRING, "ol" },
[TTYC_OP] = { TTYCODE_STRING, "op" },
[TTYC_REV] = { TTYCODE_STRING, "rev" },
[TTYC_RGB] = { TTYCODE_FLAG, "RGB" },
@ -258,6 +259,7 @@ static const struct tty_term_code_entry tty_term_codes[] = {
[TTYC_RMKX] = { TTYCODE_STRING, "rmkx" },
[TTYC_SETAB] = { TTYCODE_STRING, "setab" },
[TTYC_SETAF] = { TTYCODE_STRING, "setaf" },
[TTYC_SETAL] = { TTYCODE_STRING, "setal" },
[TTYC_SETRGBB] = { TTYCODE_STRING, "setrgbb" },
[TTYC_SETRGBF] = { TTYCODE_STRING, "setrgbf" },
[TTYC_SETULC] = { TTYCODE_STRING, "Setulc" },

32
tty.c
View File

@ -2543,7 +2543,7 @@ tty_colours_fg(struct tty *tty, const struct grid_cell *gc)
/* Is this a 24-bit or 256-colour colour? */
if (gc->fg & COLOUR_FLAG_RGB || gc->fg & COLOUR_FLAG_256) {
if (tty_try_colour(tty, gc->fg, "38") == 0)
goto save_fg;
goto save;
/* Should not get here, already converted in tty_check_fg. */
return;
}
@ -2555,13 +2555,13 @@ tty_colours_fg(struct tty *tty, const struct grid_cell *gc)
tty_puts(tty, s);
} else
tty_putcode1(tty, TTYC_SETAF, gc->fg - 90 + 8);
goto save_fg;
goto save;
}
/* Otherwise set the foreground colour. */
tty_putcode1(tty, TTYC_SETAF, gc->fg);
save_fg:
save:
/* Save the new values in the terminal current cell. */
tc->fg = gc->fg;
}
@ -2575,7 +2575,7 @@ tty_colours_bg(struct tty *tty, const struct grid_cell *gc)
/* Is this a 24-bit or 256-colour colour? */
if (gc->bg & COLOUR_FLAG_RGB || gc->bg & COLOUR_FLAG_256) {
if (tty_try_colour(tty, gc->bg, "48") == 0)
goto save_bg;
goto save;
/* Should not get here, already converted in tty_check_bg. */
return;
}
@ -2587,13 +2587,13 @@ tty_colours_bg(struct tty *tty, const struct grid_cell *gc)
tty_puts(tty, s);
} else
tty_putcode1(tty, TTYC_SETAB, gc->bg - 90 + 8);
goto save_bg;
goto save;
}
/* Otherwise set the background colour. */
tty_putcode1(tty, TTYC_SETAB, gc->bg);
save_bg:
save:
/* Save the new values in the terminal current cell. */
tc->bg = gc->bg;
}
@ -2605,20 +2605,34 @@ tty_colours_us(struct tty *tty, const struct grid_cell *gc)
u_int c;
u_char r, g, b;
/* Clear underline colour. */
if (gc->us == 0) {
tty_putcode(tty, TTYC_OL);
goto save;
}
/* Must be an RGB colour - this should never happen. */
if (~gc->us & COLOUR_FLAG_RGB)
return;
/*
* Setulc follows the ncurses(3) one argument "direct colour"
* Setulc and setal follows the ncurses(3) one argument "direct colour"
* capability format. Calculate the colour value.
*/
colour_split_rgb(gc->us, &r, &g, &b);
c = (65536 * r) + (256 * g) + b;
/* Write the colour. */
tty_putcode1(tty, TTYC_SETULC, c);
/*
* Write the colour. Only use setal if the RGB flag is set because the
* non-RGB version may be wrong.
*/
if (tty_term_has(tty->term, TTYC_SETULC))
tty_putcode1(tty, TTYC_SETULC, c);
else if (tty_term_has(tty->term, TTYC_SETAL) &&
tty_term_has(tty->term, TTYC_RGB))
tty_putcode1(tty, TTYC_SETAL, c);
save:
/* Save the new values in the terminal current cell. */
tc->us = gc->us;
}