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