1/* $OpenBSD: resize.c,v 1.51 2024/03/21 11:30:42 nicm Exp $ */
2
3/*
4 * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
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
25void
26resize_window(struct window *w, u_int sx, u_int sy, int xpixel, int ypixel)
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, 1);
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;
53	window_resize(w, sx, sy, xpixel, ypixel);
54	log_debug("%s: @%u resized to %ux%u; layout %ux%u", __func__, w->id,
55	    sx, sy, w->layout_root->sx, w->layout_root->sy);
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);
64	notify_window("window-resized", w);
65	w->flags &= ~WINDOW_RESIZE;
66}
67
68static int
69ignore_client_size(struct client *c)
70{
71	struct client	*loop;
72
73	if (c->session == NULL)
74		return (1);
75	if (c->flags & CLIENT_NOSIZEFLAGS)
76		return (1);
77	if (c->flags & CLIENT_IGNORESIZE) {
78		/*
79		 * Ignore flagged clients if there are any attached clients
80		 * that aren't flagged.
81		 */
82		TAILQ_FOREACH (loop, &clients, entry) {
83			if (loop->session == NULL)
84				continue;
85			if (loop->flags & CLIENT_NOSIZEFLAGS)
86				continue;
87			if (~loop->flags & CLIENT_IGNORESIZE)
88				return (1);
89		}
90	}
91	if ((c->flags & CLIENT_CONTROL) &&
92	    (~c->flags & CLIENT_SIZECHANGED) &&
93	    (~c->flags & CLIENT_WINDOWSIZECHANGED))
94		return (1);
95	return (0);
96}
97
98static u_int
99clients_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
113static int
114clients_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)
118{
119	struct client		*loop;
120	struct client_window	*cw;
121	u_int			 cx, cy, n = 0;
122
123	/*
124	 * Start comparing with 0 for largest and UINT_MAX for smallest or
125	 * latest.
126	 */
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	}
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	 */
144	if (type == WINDOW_SIZE_LATEST && w != NULL)
145		n = clients_with_window(w);
146
147	/* Skip setting the size if manual */
148	if (type == WINDOW_SIZE_MANUAL)
149		goto skip;
150
151	/* Loop over the clients and work out the size. */
152	TAILQ_FOREACH(loop, &clients, entry) {
153		if (loop != c && ignore_client_size(loop)) {
154			log_debug("%s: ignoring %s (1)", __func__, loop->name);
155			continue;
156		}
157		if (loop != c && skip_client(loop, type, current, s, w)) {
158			log_debug("%s: skipping %s (1)", __func__, loop->name);
159			continue;
160		}
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		 */
167		if (type == WINDOW_SIZE_LATEST && n > 1 && loop != w->latest) {
168			log_debug("%s: %s is not latest", __func__, loop->name);
169			continue;
170		}
171
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
181		/* Work out this client's size. */
182		if (cw != NULL && cw->sx != 0 && cw->sy != 0) {
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		}
189
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) {
195			if (cx > *sx)
196				*sx = cx;
197			if (cy > *sy)
198				*sy = cy;
199		} else {
200			if (cx < *sx)
201				*sx = cx;
202			if (cy < *sy)
203				*sy = cy;
204		}
205		if (loop->tty.xpixel > *xpixel && loop->tty.ypixel > *ypixel) {
206			*xpixel = loop->tty.xpixel;
207			*ypixel = loop->tty.ypixel;
208		}
209		log_debug("%s: after %s (%ux%u), size is %ux%u", __func__,
210		    loop->name, cx, cy, *sx, *sy);
211	}
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__);
216
217skip:
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
250	/* Return whether a suitable size was found. */
251	if (type == WINDOW_SIZE_MANUAL) {
252		log_debug("%s: type is manual", __func__);
253		return (1);
254	}
255	if (type == WINDOW_SIZE_LARGEST) {
256		log_debug("%s: type is largest", __func__);
257		return (*sx != 0 && *sy != 0);
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__);
263	return (*sx != UINT_MAX && *sy != UINT_MAX);
264}
265
266static int
267default_window_size_skip_client(struct client *loop, int type,
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
284void
285default_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	 */
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;
306	}
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;
314
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	 */
319	if (!clients_calculate_size(type, 0, c, s, w,
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		}
326		log_debug("%s: using %ux%u from default-size", __func__, *sx,
327		    *sy);
328	}
329
330done:
331	/* Make sure the limits are enforced. */
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;
340	log_debug("%s: resulting size is %ux%u", __func__, *sx, *sy);
341}
342
343static int
344recalculate_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	 */
352	if (loop->session->curw == NULL)
353		return (1);
354	if (current)
355		return (loop->session->curw->window != w);
356	return (session_has(loop->session, w) == 0);
357}
358
359void
360recalculate_size(struct window *w, int now)
361{
362	u_int	sx, sy, xpixel = 0, ypixel = 0;
363	int	type, current, changed;
364
365	/*
366	 * Do not attempt to resize windows which have no pane, they must be on
367	 * the way to destruction.
368	 */
369	if (w->active == NULL)
370		return;
371	log_debug("%s: @%u is %ux%u", __func__, w->id, w->sx, w->sy);
372
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	 */
378	type = options_get_number(w->options, "window-size");
379	current = options_get_number(w->options, "aggressive-resize");
380
381	/* Look for a suitable client and get the new size. */
382	changed = clients_calculate_size(type, current, NULL, NULL, w,
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	 */
389	if (w->flags & WINDOW_RESIZE) {
390		if (!now && changed && w->new_sx == sx && w->new_sy == sy)
391			changed = 0;
392	} else {
393		if (!now && changed && w->sx == sx && w->sy == sy)
394			changed = 0;
395	}
396
397	/*
398	 * If the size hasn't changed, update the window offset but not the
399	 * size.
400	 */
401	if (!changed) {
402		log_debug("%s: @%u no size change", __func__, w->id);
403		tty_update_window_offset(w);
404		return;
405	}
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	 */
412	log_debug("%s: @%u new size %ux%u", __func__, w->id, sx, sy);
413	if (now || type == WINDOW_SIZE_MANUAL)
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	}
424}
425
426void
427recalculate_sizes(void)
428{
429	recalculate_sizes_now(0);
430}
431
432void
433recalculate_sizes_now(int now)
434{
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;
445		status_update_cache(s);
446	}
447
448	/*
449	 * Increment attached count and check the status line size for each
450	 * client.
451	 */
452	TAILQ_FOREACH(c, &clients, entry) {
453		s = c->session;
454		if (s != NULL && !(c->flags & CLIENT_UNATTACHEDFLAGS))
455			s->attached++;
456		if (ignore_client_size(c))
457			continue;
458		if (c->tty.sy <= s->statuslines || (c->flags & CLIENT_CONTROL))
459			c->flags |= CLIENT_STATUSOFF;
460		else
461			c->flags &= ~CLIENT_STATUSOFF;
462	}
463
464	/* Walk each window and adjust the size. */
465	RB_FOREACH(w, windows, &windows)
466		recalculate_size(w, now);
467}
468