Annotation of src/usr.bin/tmux/resize.c, Revision 1.47
1.47 ! nicm 1: /* $OpenBSD: resize.c,v 1.46 2021/08/25 10:18:01 nicm Exp $ */
1.1 nicm 2:
3: /*
1.19 nicm 4: * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
1.1 nicm 5: *
6: * Permission to use, copy, modify, and distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
15: * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
16: * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17: */
18:
19: #include <sys/types.h>
20:
21: #include <string.h>
22:
23: #include "tmux.h"
24:
1.27 nicm 25: void
1.35 nicm 26: resize_window(struct window *w, u_int sx, u_int sy, int xpixel, int ypixel)
1.27 nicm 27: {
28: int zoomed;
29:
30: /* Check size limits. */
31: if (sx < WINDOW_MINIMUM)
32: sx = WINDOW_MINIMUM;
33: if (sx > WINDOW_MAXIMUM)
34: sx = WINDOW_MAXIMUM;
35: if (sy < WINDOW_MINIMUM)
36: sy = WINDOW_MINIMUM;
37: if (sy > WINDOW_MAXIMUM)
38: sy = WINDOW_MAXIMUM;
39:
40: /* If the window is zoomed, unzoom. */
41: zoomed = w->flags & WINDOW_ZOOMED;
42: if (zoomed)
43: window_unzoom(w);
44:
45: /* Resize the layout first. */
46: layout_resize(w, sx, sy);
47:
48: /* Resize the window, it can be no smaller than the layout. */
49: if (sx < w->layout_root->sx)
50: sx = w->layout_root->sx;
51: if (sy < w->layout_root->sy)
52: sy = w->layout_root->sy;
1.35 nicm 53: window_resize(w, sx, sy, xpixel, ypixel);
1.46 nicm 54: log_debug("%s: @%u resized to %ux%u; layout %ux%u", __func__, w->id,
1.31 nicm 55: sx, sy, w->layout_root->sx, w->layout_root->sy);
1.27 nicm 56:
57: /* Restore the window zoom state. */
58: if (zoomed)
59: window_zoom(w->active);
60:
61: tty_update_window_offset(w);
62: server_redraw_window(w);
63: notify_window("window-layout-changed", w);
1.40 nicm 64: w->flags &= ~WINDOW_RESIZE;
1.27 nicm 65: }
1.1 nicm 66:
1.29 nicm 67: static int
68: ignore_client_size(struct client *c)
69: {
1.38 nicm 70: struct client *loop;
71:
1.29 nicm 72: if (c->session == NULL)
73: return (1);
74: if (c->flags & CLIENT_NOSIZEFLAGS)
75: return (1);
1.39 nicm 76: if (c->flags & CLIENT_IGNORESIZE) {
1.38 nicm 77: /*
1.39 nicm 78: * Ignore flagged clients if there are any attached clients
79: * that aren't flagged.
1.38 nicm 80: */
81: TAILQ_FOREACH (loop, &clients, entry) {
82: if (loop->session == NULL)
83: continue;
84: if (loop->flags & CLIENT_NOSIZEFLAGS)
85: continue;
1.39 nicm 86: if (~loop->flags & CLIENT_IGNORESIZE)
1.38 nicm 87: return (1);
88: }
89: }
1.47 ! nicm 90: if ((c->flags & CLIENT_CONTROL) &&
! 91: (~c->flags & CLIENT_SIZECHANGED) &&
! 92: (~c->flags & CLIENT_WINDOWSIZECHANGED))
1.29 nicm 93: return (1);
94: return (0);
95: }
96:
1.42 nicm 97: static u_int
98: clients_with_window(struct window *w)
99: {
100: struct client *loop;
101: u_int n = 0;
102:
103: TAILQ_FOREACH(loop, &clients, entry) {
104: if (ignore_client_size(loop) || !session_has(loop->session, w))
105: continue;
106: if (++n > 1)
107: break;
108: }
109: return (n);
110: }
111:
112: static int
1.43 nicm 113: clients_calculate_size(int type, int current, struct client *c,
114: struct session *s, struct window *w, int (*skip_client)(struct client *,
115: int, int, struct session *, struct window *), u_int *sx, u_int *sy,
116: u_int *xpixel, u_int *ypixel)
1.1 nicm 117: {
1.47 ! nicm 118: struct client *loop;
! 119: struct client_window *cw;
! 120: u_int cx, cy, n = 0;
1.42 nicm 121:
122: /*
123: * Start comparing with 0 for largest and UINT_MAX for smallest or
124: * latest.
125: */
1.47 ! nicm 126: if (type == WINDOW_SIZE_LARGEST) {
! 127: *sx = 0;
! 128: *sy = 0;
! 129: } else if (type == WINDOW_SIZE_MANUAL) {
! 130: *sx = w->manual_sx;
! 131: *sy = w->manual_sy;
! 132: log_debug("%s: manual size %ux%u", __func__, *sx, *sy);
! 133: } else {
! 134: *sx = UINT_MAX;
! 135: *sy = UINT_MAX;
! 136: }
1.42 nicm 137: *xpixel = *ypixel = 0;
138:
139: /*
140: * For latest, count the number of clients with this window. We only
141: * care if there is more than one.
142: */
1.44 nicm 143: if (type == WINDOW_SIZE_LATEST && w != NULL)
1.42 nicm 144: n = clients_with_window(w);
145:
1.47 ! nicm 146: /* Skip setting the size if manual */
! 147: if (type == WINDOW_SIZE_MANUAL)
! 148: goto skip;
! 149:
1.42 nicm 150: /* Loop over the clients and work out the size. */
151: TAILQ_FOREACH(loop, &clients, entry) {
1.43 nicm 152: if (loop != c && ignore_client_size(loop)) {
1.47 ! nicm 153: log_debug("%s: ignoring %s (1)", __func__, loop->name);
1.42 nicm 154: continue;
1.43 nicm 155: }
156: if (loop != c && skip_client(loop, type, current, s, w)) {
1.47 ! nicm 157: log_debug("%s: skipping %s (1)", __func__, loop->name);
1.42 nicm 158: continue;
1.43 nicm 159: }
1.42 nicm 160:
161: /*
162: * If there are multiple clients attached, only accept the
163: * latest client; otherwise let the only client be chosen as
164: * for smallest.
165: */
1.43 nicm 166: if (type == WINDOW_SIZE_LATEST && n > 1 && loop != w->latest) {
167: log_debug("%s: %s is not latest", __func__, loop->name);
1.42 nicm 168: continue;
1.43 nicm 169: }
1.27 nicm 170:
1.47 ! nicm 171: /*
! 172: * If the client has a per-window size, use this instead if it is
! 173: * smaller.
! 174: */
! 175: if (w != NULL)
! 176: cw = server_client_get_client_window(loop, w->id);
! 177: else
! 178: cw = NULL;
! 179:
1.42 nicm 180: /* Work out this client's size. */
1.47 ! nicm 181: if (cw != NULL) {
! 182: cx = cw->sx;
! 183: cy = cw->sy;
! 184: } else {
! 185: cx = loop->tty.sx;
! 186: cy = loop->tty.sy - status_line_size(loop);
! 187: }
1.9 nicm 188:
1.42 nicm 189: /*
190: * If it is larger or smaller than the best so far, update the
191: * new size.
192: */
193: if (type == WINDOW_SIZE_LARGEST) {
1.27 nicm 194: if (cx > *sx)
195: *sx = cx;
196: if (cy > *sy)
197: *sy = cy;
1.42 nicm 198: } else {
1.27 nicm 199: if (cx < *sx)
200: *sx = cx;
201: if (cy < *sy)
202: *sy = cy;
1.42 nicm 203: }
204: if (loop->tty.xpixel > *xpixel && loop->tty.ypixel > *ypixel) {
205: *xpixel = loop->tty.xpixel;
206: *ypixel = loop->tty.ypixel;
207: }
1.43 nicm 208: log_debug("%s: after %s (%ux%u), size is %ux%u", __func__,
209: loop->name, cx, cy, *sx, *sy);
1.42 nicm 210: }
1.46 nicm 211: if (*sx != UINT_MAX && *sy != UINT_MAX)
212: log_debug("%s: calculated size %ux%u", __func__, *sx, *sy);
213: else
214: log_debug("%s: no calculated size", __func__);
1.35 nicm 215:
1.47 ! nicm 216: skip:
! 217: /*
! 218: * Do not allow any size to be larger than the per-client window size
! 219: * if one exists.
! 220: */
! 221: if (w != NULL) {
! 222: TAILQ_FOREACH(loop, &clients, entry) {
! 223: if (loop != c && ignore_client_size(loop))
! 224: continue;
! 225: if (loop != c && skip_client(loop, type, current, s, w))
! 226: continue;
! 227:
! 228: /* Look up per-window size if any. */
! 229: if (~loop->flags & CLIENT_WINDOWSIZECHANGED)
! 230: continue;
! 231: cw = server_client_get_client_window(loop, w->id);
! 232: if (cw == NULL)
! 233: continue;
! 234:
! 235: /* Clamp the size. */
! 236: log_debug("%s: %s size for @%u is %ux%u", __func__,
! 237: loop->name, w->id, cw->sx, cw->sy);
! 238: if (cw->sx != 0 && *sx > cw->sx)
! 239: *sx = cw->sx;
! 240: if (cw->sy != 0 && *sy > cw->sy)
! 241: *sy = cw->sy;
! 242: }
! 243: }
! 244: if (*sx != UINT_MAX && *sy != UINT_MAX)
! 245: log_debug("%s: calculated size %ux%u", __func__, *sx, *sy);
! 246: else
! 247: log_debug("%s: no calculated size", __func__);
! 248:
1.42 nicm 249: /* Return whether a suitable size was found. */
1.47 ! nicm 250: if (type == WINDOW_SIZE_MANUAL) {
! 251: log_debug("%s: type is manual", __func__);
! 252: return (1);
! 253: }
1.43 nicm 254: if (type == WINDOW_SIZE_LARGEST) {
255: log_debug("%s: type is largest", __func__);
1.42 nicm 256: return (*sx != 0 && *sy != 0);
1.43 nicm 257: }
258: if (type == WINDOW_SIZE_LATEST)
259: log_debug("%s: type is latest", __func__);
260: else
261: log_debug("%s: type is smallest", __func__);
1.42 nicm 262: return (*sx != UINT_MAX && *sy != UINT_MAX);
263: }
264:
265: static int
1.43 nicm 266: default_window_size_skip_client(struct client *loop, int type,
1.42 nicm 267: __unused int current, struct session *s, struct window *w)
268: {
269: /*
270: * Latest checks separately, so do not check here. Otherwise only
271: * include clients where the session contains the window or where the
272: * session is the given session.
273: */
274: if (type == WINDOW_SIZE_LATEST)
275: return (0);
276: if (w != NULL && !session_has(loop->session, w))
277: return (1);
278: if (w == NULL && loop->session != s)
279: return (1);
280: return (0);
281: }
282:
283: void
284: default_window_size(struct client *c, struct session *s, struct window *w,
285: u_int *sx, u_int *sy, u_int *xpixel, u_int *ypixel, int type)
286: {
287: const char *value;
288:
289: /* Get type if not provided. */
290: if (type == -1)
291: type = options_get_number(global_w_options, "window-size");
292:
293: /*
294: * Latest clients can use the given client if suitable. If there is no
295: * client and no window, use the default size as for manual type.
296: */
1.46 nicm 297: if (type == WINDOW_SIZE_LATEST && c != NULL && !ignore_client_size(c)) {
298: *sx = c->tty.sx;
299: *sy = c->tty.sy - status_line_size(c);
300: *xpixel = c->tty.xpixel;
301: *ypixel = c->tty.ypixel;
302: log_debug("%s: using %ux%u from %s", __func__, *sx, *sy,
303: c->name);
304: goto done;
1.27 nicm 305: }
1.45 nicm 306:
307: /*
308: * Ignore the given client if it is a control client - the creating
309: * client should only affect the size if it is not a control client.
310: */
311: if (c != NULL && (c->flags & CLIENT_CONTROL))
312: c = NULL;
1.27 nicm 313:
1.42 nicm 314: /*
315: * Look for a client to base the size on. If none exists (or the type
316: * is manual), use the default-size option.
317: */
1.43 nicm 318: if (!clients_calculate_size(type, 0, c, s, w,
1.42 nicm 319: default_window_size_skip_client, sx, sy, xpixel, ypixel)) {
320: value = options_get_string(s->options, "default-size");
321: if (sscanf(value, "%ux%u", sx, sy) != 2) {
322: *sx = 80;
323: *sy = 24;
324: }
1.43 nicm 325: log_debug("%s: using %ux%u from default-size", __func__, *sx,
326: *sy);
1.27 nicm 327: }
328:
329: done:
1.42 nicm 330: /* Make sure the limits are enforced. */
1.27 nicm 331: if (*sx < WINDOW_MINIMUM)
332: *sx = WINDOW_MINIMUM;
333: if (*sx > WINDOW_MAXIMUM)
334: *sx = WINDOW_MAXIMUM;
335: if (*sy < WINDOW_MINIMUM)
336: *sy = WINDOW_MINIMUM;
337: if (*sy > WINDOW_MAXIMUM)
338: *sy = WINDOW_MAXIMUM;
1.43 nicm 339: log_debug("%s: resulting size is %ux%u", __func__, *sx, *sy);
1.27 nicm 340: }
1.1 nicm 341:
1.42 nicm 342: static int
343: recalculate_size_skip_client(struct client *loop, __unused int type,
344: int current, __unused struct session *s, struct window *w)
345: {
346: /*
347: * If the current flag is set, then skip any client where this window
348: * is not the current window - this is used for aggressive-resize.
349: * Otherwise skip any session that doesn't contain the window.
350: */
351: if (current)
352: return (loop->session->curw->window != w);
353: return (session_has(loop->session, w) == 0);
354: }
355:
1.27 nicm 356: void
1.41 nicm 357: recalculate_size(struct window *w, int now)
1.33 nicm 358: {
1.42 nicm 359: u_int sx, sy, xpixel = 0, ypixel = 0;
360: int type, current, changed;
1.33 nicm 361:
1.42 nicm 362: /*
363: * Do not attempt to resize windows which have no pane, they must be on
364: * the way to destruction.
365: */
1.33 nicm 366: if (w->active == NULL)
367: return;
1.46 nicm 368: log_debug("%s: @%u is %ux%u", __func__, w->id, w->sx, w->sy);
1.33 nicm 369:
1.42 nicm 370: /*
371: * Type is manual, smallest, largest, latest. Current is the
372: * aggressive-resize option (do not resize based on clients where the
373: * window is not the current window).
374: */
1.33 nicm 375: type = options_get_number(w->options, "window-size");
376: current = options_get_number(w->options, "aggressive-resize");
377:
1.42 nicm 378: /* Look for a suitable client and get the new size. */
1.43 nicm 379: changed = clients_calculate_size(type, current, NULL, NULL, w,
1.42 nicm 380: recalculate_size_skip_client, &sx, &sy, &xpixel, &ypixel);
381:
382: /*
383: * Make sure the size has actually changed. If the window has already
384: * got a resize scheduled, then use the new size; otherwise the old.
385: */
1.40 nicm 386: if (w->flags & WINDOW_RESIZE) {
1.41 nicm 387: if (!now && changed && w->new_sx == sx && w->new_sy == sy)
1.40 nicm 388: changed = 0;
389: } else {
1.41 nicm 390: if (!now && changed && w->sx == sx && w->sy == sy)
1.40 nicm 391: changed = 0;
392: }
1.33 nicm 393:
1.42 nicm 394: /*
395: * If the size hasn't changed, update the window offset but not the
396: * size.
397: */
1.33 nicm 398: if (!changed) {
1.46 nicm 399: log_debug("%s: @%u no size change", __func__, w->id);
1.33 nicm 400: tty_update_window_offset(w);
401: return;
402: }
1.42 nicm 403:
404: /*
405: * If the now flag is set or if the window is sized manually, change
406: * the size immediately. Otherwise set the flag and it will be done
407: * later.
408: */
1.46 nicm 409: log_debug("%s: @%u new size %ux%u", __func__, w->id, sx, sy);
1.41 nicm 410: if (now || type == WINDOW_SIZE_MANUAL)
1.40 nicm 411: resize_window(w, sx, sy, xpixel, ypixel);
412: else {
413: w->new_sx = sx;
414: w->new_sy = sy;
415: w->new_xpixel = xpixel;
416: w->new_ypixel = ypixel;
417:
418: w->flags |= WINDOW_RESIZE;
419: tty_update_window_offset(w);
420: }
1.33 nicm 421: }
422:
423: void
1.27 nicm 424: recalculate_sizes(void)
425: {
1.41 nicm 426: recalculate_sizes_now(0);
427: }
428:
429: void
430: recalculate_sizes_now(int now)
431: {
1.27 nicm 432: struct session *s;
433: struct client *c;
434: struct window *w;
435:
436: /*
437: * Clear attached count and update saved status line information for
438: * each session.
439: */
440: RB_FOREACH(s, sessions, &sessions) {
441: s->attached = 0;
1.30 nicm 442: status_update_cache(s);
1.27 nicm 443: }
1.9 nicm 444:
1.27 nicm 445: /*
446: * Increment attached count and check the status line size for each
447: * client.
448: */
449: TAILQ_FOREACH(c, &clients, entry) {
1.37 nicm 450: s = c->session;
451: if (s != NULL && !(c->flags & CLIENT_UNATTACHEDFLAGS))
452: s->attached++;
1.29 nicm 453: if (ignore_client_size(c))
1.27 nicm 454: continue;
1.32 nicm 455: if (c->tty.sy <= s->statuslines || (c->flags & CLIENT_CONTROL))
1.27 nicm 456: c->flags |= CLIENT_STATUSOFF;
457: else
458: c->flags &= ~CLIENT_STATUSOFF;
1.1 nicm 459: }
460:
1.27 nicm 461: /* Walk each window and adjust the size. */
1.33 nicm 462: RB_FOREACH(w, windows, &windows)
1.41 nicm 463: recalculate_size(w, now);
1.1 nicm 464: }