1 /* $OpenBSD$ */
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
25 void
resize_window(struct window * w,u_int sx,u_int sy,int xpixel,int ypixel)26 resize_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
68 static int
ignore_client_size(struct client * c)69 ignore_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
98 static u_int
clients_with_window(struct window * w)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
clients_calculate_size(int type,int current,struct client * c,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)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)
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
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
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
266 static int
default_window_size_skip_client(struct client * loop,int type,__unused int current,struct session * s,struct window * w)267 default_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
284 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)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 */
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
330 done:
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
343 static int
recalculate_size_skip_client(struct client * loop,__unused int type,int current,__unused struct session * s,struct window * w)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 */
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
359 void
recalculate_size(struct window * w,int now)360 recalculate_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
426 void
recalculate_sizes(void)427 recalculate_sizes(void)
428 {
429 recalculate_sizes_now(0);
430 }
431
432 void
recalculate_sizes_now(int now)433 recalculate_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