Annotation of src/usr.bin/tmux/resize.c, Revision 1.50
1.50 ! nicm 1: /* $OpenBSD: resize.c,v 1.49 2022/01/06 08:20:00 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.50 ! nicm 64: notify_window("window-resized", w);
1.40 nicm 65: w->flags &= ~WINDOW_RESIZE;
1.27 nicm 66: }
1.1 nicm 67:
1.29 nicm 68: static int
69: ignore_client_size(struct client *c)
70: {
1.38 nicm 71: struct client *loop;
72:
1.29 nicm 73: if (c->session == NULL)
74: return (1);
75: if (c->flags & CLIENT_NOSIZEFLAGS)
76: return (1);
1.39 nicm 77: if (c->flags & CLIENT_IGNORESIZE) {
1.38 nicm 78: /*
1.39 nicm 79: * Ignore flagged clients if there are any attached clients
80: * that aren't flagged.
1.38 nicm 81: */
82: TAILQ_FOREACH (loop, &clients, entry) {
83: if (loop->session == NULL)
84: continue;
85: if (loop->flags & CLIENT_NOSIZEFLAGS)
86: continue;
1.39 nicm 87: if (~loop->flags & CLIENT_IGNORESIZE)
1.38 nicm 88: return (1);
89: }
90: }
1.47 nicm 91: if ((c->flags & CLIENT_CONTROL) &&
92: (~c->flags & CLIENT_SIZECHANGED) &&
93: (~c->flags & CLIENT_WINDOWSIZECHANGED))
1.29 nicm 94: return (1);
95: return (0);
96: }
97:
1.42 nicm 98: static u_int
99: clients_with_window(struct window *w)
100: {
101: struct client *loop;
102: u_int n = 0;
103:
104: TAILQ_FOREACH(loop, &clients, entry) {
105: if (ignore_client_size(loop) || !session_has(loop->session, w))
106: continue;
107: if (++n > 1)
108: break;
109: }
110: return (n);
111: }
112:
113: static int
1.43 nicm 114: clients_calculate_size(int type, int current, struct client *c,
115: struct session *s, struct window *w, int (*skip_client)(struct client *,
116: int, int, struct session *, struct window *), u_int *sx, u_int *sy,
117: u_int *xpixel, u_int *ypixel)
1.1 nicm 118: {
1.47 nicm 119: struct client *loop;
120: struct client_window *cw;
121: u_int cx, cy, n = 0;
1.42 nicm 122:
123: /*
124: * Start comparing with 0 for largest and UINT_MAX for smallest or
125: * latest.
126: */
1.47 nicm 127: if (type == WINDOW_SIZE_LARGEST) {
128: *sx = 0;
129: *sy = 0;
130: } else if (type == WINDOW_SIZE_MANUAL) {
131: *sx = w->manual_sx;
132: *sy = w->manual_sy;
133: log_debug("%s: manual size %ux%u", __func__, *sx, *sy);
134: } else {
135: *sx = UINT_MAX;
136: *sy = UINT_MAX;
137: }
1.42 nicm 138: *xpixel = *ypixel = 0;
139:
140: /*
141: * For latest, count the number of clients with this window. We only
142: * care if there is more than one.
143: */
1.44 nicm 144: if (type == WINDOW_SIZE_LATEST && w != NULL)
1.42 nicm 145: n = clients_with_window(w);
146:
1.47 nicm 147: /* Skip setting the size if manual */
148: if (type == WINDOW_SIZE_MANUAL)
149: goto skip;
150:
1.42 nicm 151: /* Loop over the clients and work out the size. */
152: TAILQ_FOREACH(loop, &clients, entry) {
1.43 nicm 153: if (loop != c && ignore_client_size(loop)) {
1.47 nicm 154: log_debug("%s: ignoring %s (1)", __func__, loop->name);
1.42 nicm 155: continue;
1.43 nicm 156: }
157: if (loop != c && skip_client(loop, type, current, s, w)) {
1.47 nicm 158: log_debug("%s: skipping %s (1)", __func__, loop->name);
1.42 nicm 159: continue;
1.43 nicm 160: }
1.42 nicm 161:
162: /*
163: * If there are multiple clients attached, only accept the
164: * latest client; otherwise let the only client be chosen as
165: * for smallest.
166: */
1.43 nicm 167: if (type == WINDOW_SIZE_LATEST && n > 1 && loop != w->latest) {
168: log_debug("%s: %s is not latest", __func__, loop->name);
1.42 nicm 169: continue;
1.43 nicm 170: }
1.27 nicm 171:
1.47 nicm 172: /*
173: * If the client has a per-window size, use this instead if it is
174: * smaller.
175: */
176: if (w != NULL)
177: cw = server_client_get_client_window(loop, w->id);
178: else
179: cw = NULL;
180:
1.42 nicm 181: /* Work out this client's size. */
1.49 nicm 182: if (cw != NULL && cw->sx != 0 && cw->sy != 0) {
1.47 nicm 183: cx = cw->sx;
184: cy = cw->sy;
185: } else {
186: cx = loop->tty.sx;
187: cy = loop->tty.sy - status_line_size(loop);
188: }
1.9 nicm 189:
1.42 nicm 190: /*
191: * If it is larger or smaller than the best so far, update the
192: * new size.
193: */
194: if (type == WINDOW_SIZE_LARGEST) {
1.27 nicm 195: if (cx > *sx)
196: *sx = cx;
197: if (cy > *sy)
198: *sy = cy;
1.42 nicm 199: } else {
1.27 nicm 200: if (cx < *sx)
201: *sx = cx;
202: if (cy < *sy)
203: *sy = cy;
1.42 nicm 204: }
205: if (loop->tty.xpixel > *xpixel && loop->tty.ypixel > *ypixel) {
206: *xpixel = loop->tty.xpixel;
207: *ypixel = loop->tty.ypixel;
208: }
1.43 nicm 209: log_debug("%s: after %s (%ux%u), size is %ux%u", __func__,
210: loop->name, cx, cy, *sx, *sy);
1.42 nicm 211: }
1.46 nicm 212: if (*sx != UINT_MAX && *sy != UINT_MAX)
213: log_debug("%s: calculated size %ux%u", __func__, *sx, *sy);
214: else
215: log_debug("%s: no calculated size", __func__);
1.35 nicm 216:
1.47 nicm 217: skip:
218: /*
219: * Do not allow any size to be larger than the per-client window size
220: * if one exists.
221: */
222: if (w != NULL) {
223: TAILQ_FOREACH(loop, &clients, entry) {
224: if (loop != c && ignore_client_size(loop))
225: continue;
226: if (loop != c && skip_client(loop, type, current, s, w))
227: continue;
228:
229: /* Look up per-window size if any. */
230: if (~loop->flags & CLIENT_WINDOWSIZECHANGED)
231: continue;
232: cw = server_client_get_client_window(loop, w->id);
233: if (cw == NULL)
234: continue;
235:
236: /* Clamp the size. */
237: log_debug("%s: %s size for @%u is %ux%u", __func__,
238: loop->name, w->id, cw->sx, cw->sy);
239: if (cw->sx != 0 && *sx > cw->sx)
240: *sx = cw->sx;
241: if (cw->sy != 0 && *sy > cw->sy)
242: *sy = cw->sy;
243: }
244: }
245: if (*sx != UINT_MAX && *sy != UINT_MAX)
246: log_debug("%s: calculated size %ux%u", __func__, *sx, *sy);
247: else
248: log_debug("%s: no calculated size", __func__);
249:
1.42 nicm 250: /* Return whether a suitable size was found. */
1.47 nicm 251: if (type == WINDOW_SIZE_MANUAL) {
252: log_debug("%s: type is manual", __func__);
253: return (1);
254: }
1.43 nicm 255: if (type == WINDOW_SIZE_LARGEST) {
256: log_debug("%s: type is largest", __func__);
1.42 nicm 257: return (*sx != 0 && *sy != 0);
1.43 nicm 258: }
259: if (type == WINDOW_SIZE_LATEST)
260: log_debug("%s: type is latest", __func__);
261: else
262: log_debug("%s: type is smallest", __func__);
1.42 nicm 263: return (*sx != UINT_MAX && *sy != UINT_MAX);
264: }
265:
266: static int
1.43 nicm 267: default_window_size_skip_client(struct client *loop, int type,
1.42 nicm 268: __unused int current, struct session *s, struct window *w)
269: {
270: /*
271: * Latest checks separately, so do not check here. Otherwise only
272: * include clients where the session contains the window or where the
273: * session is the given session.
274: */
275: if (type == WINDOW_SIZE_LATEST)
276: return (0);
277: if (w != NULL && !session_has(loop->session, w))
278: return (1);
279: if (w == NULL && loop->session != s)
280: return (1);
281: return (0);
282: }
283:
284: void
285: default_window_size(struct client *c, struct session *s, struct window *w,
286: u_int *sx, u_int *sy, u_int *xpixel, u_int *ypixel, int type)
287: {
288: const char *value;
289:
290: /* Get type if not provided. */
291: if (type == -1)
292: type = options_get_number(global_w_options, "window-size");
293:
294: /*
295: * Latest clients can use the given client if suitable. If there is no
296: * client and no window, use the default size as for manual type.
297: */
1.46 nicm 298: if (type == WINDOW_SIZE_LATEST && c != NULL && !ignore_client_size(c)) {
299: *sx = c->tty.sx;
300: *sy = c->tty.sy - status_line_size(c);
301: *xpixel = c->tty.xpixel;
302: *ypixel = c->tty.ypixel;
303: log_debug("%s: using %ux%u from %s", __func__, *sx, *sy,
304: c->name);
305: goto done;
1.27 nicm 306: }
1.45 nicm 307:
308: /*
309: * Ignore the given client if it is a control client - the creating
310: * client should only affect the size if it is not a control client.
311: */
312: if (c != NULL && (c->flags & CLIENT_CONTROL))
313: c = NULL;
1.27 nicm 314:
1.42 nicm 315: /*
316: * Look for a client to base the size on. If none exists (or the type
317: * is manual), use the default-size option.
318: */
1.43 nicm 319: if (!clients_calculate_size(type, 0, c, s, w,
1.42 nicm 320: default_window_size_skip_client, sx, sy, xpixel, ypixel)) {
321: value = options_get_string(s->options, "default-size");
322: if (sscanf(value, "%ux%u", sx, sy) != 2) {
323: *sx = 80;
324: *sy = 24;
325: }
1.43 nicm 326: log_debug("%s: using %ux%u from default-size", __func__, *sx,
327: *sy);
1.27 nicm 328: }
329:
330: done:
1.42 nicm 331: /* Make sure the limits are enforced. */
1.27 nicm 332: if (*sx < WINDOW_MINIMUM)
333: *sx = WINDOW_MINIMUM;
334: if (*sx > WINDOW_MAXIMUM)
335: *sx = WINDOW_MAXIMUM;
336: if (*sy < WINDOW_MINIMUM)
337: *sy = WINDOW_MINIMUM;
338: if (*sy > WINDOW_MAXIMUM)
339: *sy = WINDOW_MAXIMUM;
1.43 nicm 340: log_debug("%s: resulting size is %ux%u", __func__, *sx, *sy);
1.27 nicm 341: }
1.1 nicm 342:
1.42 nicm 343: static int
344: recalculate_size_skip_client(struct client *loop, __unused int type,
345: int current, __unused struct session *s, struct window *w)
346: {
347: /*
348: * If the current flag is set, then skip any client where this window
349: * is not the current window - this is used for aggressive-resize.
350: * Otherwise skip any session that doesn't contain the window.
351: */
1.48 nicm 352: if (loop->session->curw == NULL)
353: return (1);
1.42 nicm 354: if (current)
355: return (loop->session->curw->window != w);
356: return (session_has(loop->session, w) == 0);
357: }
358:
1.27 nicm 359: void
1.41 nicm 360: recalculate_size(struct window *w, int now)
1.33 nicm 361: {
1.42 nicm 362: u_int sx, sy, xpixel = 0, ypixel = 0;
363: int type, current, changed;
1.33 nicm 364:
1.42 nicm 365: /*
366: * Do not attempt to resize windows which have no pane, they must be on
367: * the way to destruction.
368: */
1.33 nicm 369: if (w->active == NULL)
370: return;
1.46 nicm 371: log_debug("%s: @%u is %ux%u", __func__, w->id, w->sx, w->sy);
1.33 nicm 372:
1.42 nicm 373: /*
374: * Type is manual, smallest, largest, latest. Current is the
375: * aggressive-resize option (do not resize based on clients where the
376: * window is not the current window).
377: */
1.33 nicm 378: type = options_get_number(w->options, "window-size");
379: current = options_get_number(w->options, "aggressive-resize");
380:
1.42 nicm 381: /* Look for a suitable client and get the new size. */
1.43 nicm 382: changed = clients_calculate_size(type, current, NULL, NULL, w,
1.42 nicm 383: recalculate_size_skip_client, &sx, &sy, &xpixel, &ypixel);
384:
385: /*
386: * Make sure the size has actually changed. If the window has already
387: * got a resize scheduled, then use the new size; otherwise the old.
388: */
1.40 nicm 389: if (w->flags & WINDOW_RESIZE) {
1.41 nicm 390: if (!now && changed && w->new_sx == sx && w->new_sy == sy)
1.40 nicm 391: changed = 0;
392: } else {
1.41 nicm 393: if (!now && changed && w->sx == sx && w->sy == sy)
1.40 nicm 394: changed = 0;
395: }
1.33 nicm 396:
1.42 nicm 397: /*
398: * If the size hasn't changed, update the window offset but not the
399: * size.
400: */
1.33 nicm 401: if (!changed) {
1.46 nicm 402: log_debug("%s: @%u no size change", __func__, w->id);
1.33 nicm 403: tty_update_window_offset(w);
404: return;
405: }
1.42 nicm 406:
407: /*
408: * If the now flag is set or if the window is sized manually, change
409: * the size immediately. Otherwise set the flag and it will be done
410: * later.
411: */
1.46 nicm 412: log_debug("%s: @%u new size %ux%u", __func__, w->id, sx, sy);
1.41 nicm 413: if (now || type == WINDOW_SIZE_MANUAL)
1.40 nicm 414: resize_window(w, sx, sy, xpixel, ypixel);
415: else {
416: w->new_sx = sx;
417: w->new_sy = sy;
418: w->new_xpixel = xpixel;
419: w->new_ypixel = ypixel;
420:
421: w->flags |= WINDOW_RESIZE;
422: tty_update_window_offset(w);
423: }
1.33 nicm 424: }
425:
426: void
1.27 nicm 427: recalculate_sizes(void)
428: {
1.41 nicm 429: recalculate_sizes_now(0);
430: }
431:
432: void
433: recalculate_sizes_now(int now)
434: {
1.27 nicm 435: struct session *s;
436: struct client *c;
437: struct window *w;
438:
439: /*
440: * Clear attached count and update saved status line information for
441: * each session.
442: */
443: RB_FOREACH(s, sessions, &sessions) {
444: s->attached = 0;
1.30 nicm 445: status_update_cache(s);
1.27 nicm 446: }
1.9 nicm 447:
1.27 nicm 448: /*
449: * Increment attached count and check the status line size for each
450: * client.
451: */
452: TAILQ_FOREACH(c, &clients, entry) {
1.37 nicm 453: s = c->session;
454: if (s != NULL && !(c->flags & CLIENT_UNATTACHEDFLAGS))
455: s->attached++;
1.29 nicm 456: if (ignore_client_size(c))
1.27 nicm 457: continue;
1.32 nicm 458: if (c->tty.sy <= s->statuslines || (c->flags & CLIENT_CONTROL))
1.27 nicm 459: c->flags |= CLIENT_STATUSOFF;
460: else
461: c->flags &= ~CLIENT_STATUSOFF;
1.1 nicm 462: }
463:
1.27 nicm 464: /* Walk each window and adjust the size. */
1.33 nicm 465: RB_FOREACH(w, windows, &windows)
1.41 nicm 466: recalculate_size(w, now);
1.1 nicm 467: }
![[BACK]](/icons/back.gif){kind=icon}
Return to resize.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / tmux