circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2025-09-03 22:43:58 +00:00
Code Issues Projects Releases Wiki Activity

Tidy the resize code, merge some common bits and add some comments. From

Browse Source 
"Mike" in GitHub issue 2392.
This commit is contained in:
nicm
2020-10-05 10:00:51 +00:00
parent c8f3736b07
commit 1479e32e1a
1 changed files with 167 additions and 208 deletions
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); return (0);
} }
void static u_int
default_window_size(struct client *c, struct session *s, struct window *w, clients_with_window(struct window *w)
u_int *sx, u_int *sy, u_int *xpixel, u_int *ypixel, int type)
{ {
struct client *loop; struct client *loop;
u_int cx, cy, n; u_int n = 0;
const char *value;
if (type == -1) TAILQ_FOREACH(loop, &clients, entry) {
type = options_get_number(global_w_options, "window-size"); if (ignore_client_size(loop) || !session_has(loop->session, w))
switch (type) { continue;
case WINDOW_SIZE_LARGEST: 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; *sx = *sy = 0;
*xpixel = *ypixel = 0; else
TAILQ_FOREACH(loop, &clients, entry) { *sx = *sy = UINT_MAX;
if (ignore_client_size(loop)) *xpixel = *ypixel = 0;
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); * 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) if (cx > *sx)
*sx = cx; *sx = cx;
if (cy > *sy) if (cy > *sy)
*sy = cy; *sy = cy;
} else {
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);
if (cx < *sx) if (cx < *sx)
*sx = cx; *sx = cx;
if (cy < *sy) if (cy < *sy)
*sy = cy; *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) if (loop->tty.xpixel > *xpixel && loop->tty.ypixel > *ypixel) {
goto manual; *xpixel = loop->tty.xpixel;
break; *ypixel = loop->tty.ypixel;
case WINDOW_SIZE_LATEST: }
}
/* 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)) { if (c != NULL && !ignore_client_size(c)) {
*sx = c->tty.sx; *sx = c->tty.sx;
*sy = c->tty.sy - status_line_size(c); *sy = c->tty.sy - status_line_size(c);
*xpixel = c->tty.xpixel; *xpixel = c->tty.xpixel;
*ypixel = c->tty.ypixel; *ypixel = c->tty.ypixel;
} else { goto done;
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;
} }
break; if (w == NULL)
case WINDOW_SIZE_MANUAL: type = WINDOW_SIZE_MANUAL;
goto manual;
} }
goto done;
manual: /*
value = options_get_string(s->options, "default-size"); * Look for a client to base the size on. If none exists (or the type
if (sscanf(value, "%ux%u", sx, sy) != 2) { * is manual), use the default-size option.
*sx = 80; */
*sy = 24; 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: done:
/* Make sure the limits are enforced. */
if (*sx < WINDOW_MINIMUM) if (*sx < WINDOW_MINIMUM)
*sx = WINDOW_MINIMUM; *sx = WINDOW_MINIMUM;
if (*sx > WINDOW_MAXIMUM) if (*sx > WINDOW_MAXIMUM)
@ -226,127 +252,50 @@ done:
*sy = WINDOW_MAXIMUM; *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 void
recalculate_size(struct window *w, int now) recalculate_size(struct window *w, int now)
{ {
struct session *s; u_int sx, sy, xpixel = 0, ypixel = 0;
struct client *c; int type, current, changed;
u_int sx, sy, cx, cy, xpixel = 0, ypixel = 0, n;
int type, current, has, changed;
/*
* Do not attempt to resize windows which have no pane, they must be on
* the way to destruction.
*/
if (w->active == NULL) if (w->active == NULL)
return; return;
log_debug("%s: @%u is %u,%u", __func__, w->id, w->sx, w->sy); 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"); type = options_get_number(w->options, "window-size");
current = options_get_number(w->options, "aggressive-resize"); current = options_get_number(w->options, "aggressive-resize");
changed = 1; /* Look for a suitable client and get the new size. */
switch (type) { changed = clients_calculate_size(type, current, NULL, w,
case WINDOW_SIZE_LARGEST: recalculate_size_skip_client, &sx, &sy, &xpixel, &ypixel);
sx = sy = 0;
TAILQ_FOREACH(c, &clients, entry) {
if (ignore_client_size(c))
continue;
s = c->session;
if (current) /*
has = (s->curw->window == w); * Make sure the size has actually changed. If the window has already
else * got a resize scheduled, then use the new size; otherwise the old.
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;
}
if (w->flags & WINDOW_RESIZE) { if (w->flags & WINDOW_RESIZE) {
if (!now && changed && w->new_sx == sx && w->new_sy == sy) if (!now && changed && w->new_sx == sx && w->new_sy == sy)
changed = 0; changed = 0;
@ -355,10 +304,20 @@ recalculate_size(struct window *w, int now)
changed = 0; changed = 0;
} }
/*
* If the size hasn't changed, update the window offset but not the
* size.
*/
if (!changed) { if (!changed) {
tty_update_window_offset(w); tty_update_window_offset(w);
return; 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); log_debug("%s: @%u new size %u,%u", __func__, w->id, sx, sy);
if (now || type == WINDOW_SIZE_MANUAL) if (now || type == WINDOW_SIZE_MANUAL)
resize_window(w, sx, sy, xpixel, ypixel); resize_window(w, sx, sy, xpixel, ypixel);