/* $OpenBSD$ */ /* * Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com> * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #include <sys/types.h> #include <string.h> #include "tmux.h" void resize_window(struct window *w, u_int sx, u_int sy, int xpixel, int ypixel) { int zoomed; /* Check size limits. */ if (sx < WINDOW_MINIMUM) sx = WINDOW_MINIMUM; if (sx > WINDOW_MAXIMUM) sx = WINDOW_MAXIMUM; if (sy < WINDOW_MINIMUM) sy = WINDOW_MINIMUM; if (sy > WINDOW_MAXIMUM) sy = WINDOW_MAXIMUM; /* If the window is zoomed, unzoom. */ zoomed = w->flags & WINDOW_ZOOMED; if (zoomed) window_unzoom(w, 1); /* Resize the layout first. */ layout_resize(w, sx, sy); /* Resize the window, it can be no smaller than the layout. */ if (sx < w->layout_root->sx) sx = w->layout_root->sx; if (sy < w->layout_root->sy) sy = w->layout_root->sy; window_resize(w, sx, sy, xpixel, ypixel); log_debug("%s: @%u resized to %ux%u; layout %ux%u", __func__, w->id, sx, sy, w->layout_root->sx, w->layout_root->sy); /* Restore the window zoom state. */ if (zoomed) window_zoom(w->active); tty_update_window_offset(w); server_redraw_window(w); notify_window("window-layout-changed", w); notify_window("window-resized", w); w->flags &= ~WINDOW_RESIZE; } static int ignore_client_size(struct client *c) { struct client *loop; if (c->session == NULL) return (1); if (c->flags & CLIENT_NOSIZEFLAGS) return (1); if (c->flags & CLIENT_IGNORESIZE) { /* * Ignore flagged clients if there are any attached clients * that aren't flagged. */ TAILQ_FOREACH (loop, &clients, entry) { if (loop->session == NULL) continue; if (loop->flags & CLIENT_NOSIZEFLAGS) continue; if (~loop->flags & CLIENT_IGNORESIZE) return (1); } } if ((c->flags & CLIENT_CONTROL) && (~c->flags & CLIENT_SIZECHANGED) && (~c->flags & CLIENT_WINDOWSIZECHANGED)) return (1); return (0); } static u_int clients_with_window(struct window *w) { struct client *loop; u_int n = 0; TAILQ_FOREACH(loop, &clients, entry) { if (ignore_client_size(loop) || !session_has(loop->session, w)) continue; if (++n > 1) break; } return (n); } 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) { struct client *loop; struct client_window *cw; u_int cx, cy, n = 0; /* * Start comparing with 0 for largest and UINT_MAX for smallest or * latest. */ if (type == WINDOW_SIZE_LARGEST) { *sx = 0; *sy = 0; } else if (type == WINDOW_SIZE_MANUAL) { *sx = w->manual_sx; *sy = w->manual_sy; log_debug("%s: manual size %ux%u", __func__, *sx, *sy); } else { *sx = UINT_MAX; *sy = UINT_MAX; } *xpixel = *ypixel = 0; /* * For latest, count the number of clients with this window. We only * care if there is more than one. */ if (type == WINDOW_SIZE_LATEST && w != NULL) n = clients_with_window(w); /* Skip setting the size if manual */ if (type == WINDOW_SIZE_MANUAL) goto skip; /* Loop over the clients and work out the size. */ TAILQ_FOREACH(loop, &clients, entry) { if (loop != c && ignore_client_size(loop)) { log_debug("%s: ignoring %s (1)", __func__, loop->name); continue; } if (loop != c && skip_client(loop, type, current, s, w)) { log_debug("%s: skipping %s (1)", __func__, loop->name); continue; } /* * If there are multiple clients attached, only accept the * latest client; otherwise let the only client be chosen as * for smallest. */ if (type == WINDOW_SIZE_LATEST && n > 1 && loop != w->latest) { log_debug("%s: %s is not latest", __func__, loop->name); continue; } /* * If the client has a per-window size, use this instead if it is * smaller. */ if (w != NULL) cw = server_client_get_client_window(loop, w->id); else cw = NULL; /* Work out this client's size. */ if (cw != NULL && cw->sx != 0 && cw->sy != 0) { cx = cw->sx; cy = cw->sy; } else { cx = loop->tty.sx; cy = loop->tty.sy - status_line_size(loop); } /* * If it is larger or smaller than the best so far, update the * new size. */ if (type == WINDOW_SIZE_LARGEST) { if (cx > *sx) *sx = cx; if (cy > *sy) *sy = cy; } else { if (cx < *sx) *sx = cx; if (cy < *sy) *sy = cy; } if (loop->tty.xpixel > *xpixel && loop->tty.ypixel > *ypixel) { *xpixel = loop->tty.xpixel; *ypixel = loop->tty.ypixel; } log_debug("%s: after %s (%ux%u), size is %ux%u", __func__, loop->name, cx, cy, *sx, *sy); } if (*sx != UINT_MAX && *sy != UINT_MAX) log_debug("%s: calculated size %ux%u", __func__, *sx, *sy); else log_debug("%s: no calculated size", __func__); skip: /* * Do not allow any size to be larger than the per-client window size * if one exists. */ if (w != NULL) { TAILQ_FOREACH(loop, &clients, entry) { if (loop != c && ignore_client_size(loop)) continue; if (loop != c && skip_client(loop, type, current, s, w)) continue; /* Look up per-window size if any. */ if (~loop->flags & CLIENT_WINDOWSIZECHANGED) continue; cw = server_client_get_client_window(loop, w->id); if (cw == NULL) continue; /* Clamp the size. */ log_debug("%s: %s size for @%u is %ux%u", __func__, loop->name, w->id, cw->sx, cw->sy); if (cw->sx != 0 && *sx > cw->sx) *sx = cw->sx; if (cw->sy != 0 && *sy > cw->sy) *sy = cw->sy; } } if (*sx != UINT_MAX && *sy != UINT_MAX) log_debug("%s: calculated size %ux%u", __func__, *sx, *sy); else log_debug("%s: no calculated size", __func__); /* Return whether a suitable size was found. */ if (type == WINDOW_SIZE_MANUAL) { log_debug("%s: type is manual", __func__); return (1); } if (type == WINDOW_SIZE_LARGEST) { log_debug("%s: type is largest", __func__); return (*sx != 0 && *sy != 0); } if (type == WINDOW_SIZE_LATEST) log_debug("%s: type is latest", __func__); else log_debug("%s: type is smallest", __func__); return (*sx != UINT_MAX && *sy != UINT_MAX); } static int default_window_size_skip_client(struct client *loop, int type, __unused int current, struct session *s, struct window *w) { /* * Latest checks separately, so do not check here. Otherwise only * include clients where the session contains the window or where the * session is the given session. */ if (type == WINDOW_SIZE_LATEST) return (0); if (w != NULL && !session_has(loop->session, w)) return (1); if (w == NULL && loop->session != s) return (1); return (0); } 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) { const char *value; /* Get type if not provided. */ if (type == -1) type = options_get_number(global_w_options, "window-size"); /* * Latest clients can use the given client if suitable. If there is no * client and no window, use the default size as for manual type. */ if (type == WINDOW_SIZE_LATEST && c != NULL && !ignore_client_size(c)) { *sx = c->tty.sx; *sy = c->tty.sy - status_line_size(c); *xpixel = c->tty.xpixel; *ypixel = c->tty.ypixel; log_debug("%s: using %ux%u from %s", __func__, *sx, *sy, c->name); goto done; } /* * Ignore the given client if it is a control client - the creating * client should only affect the size if it is not a control client. */ if (c != NULL && (c->flags & CLIENT_CONTROL)) c = NULL; /* * Look for a client to base the size on. If none exists (or the type * is manual), use the default-size option. */ if (!clients_calculate_size(type, 0, c, s, w, default_window_size_skip_client, sx, sy, xpixel, ypixel)) { value = options_get_string(s->options, "default-size"); if (sscanf(value, "%ux%u", sx, sy) != 2) { *sx = 80; *sy = 24; } log_debug("%s: using %ux%u from default-size", __func__, *sx, *sy); } done: /* Make sure the limits are enforced. */ if (*sx < WINDOW_MINIMUM) *sx = WINDOW_MINIMUM; if (*sx > WINDOW_MAXIMUM) *sx = WINDOW_MAXIMUM; if (*sy < WINDOW_MINIMUM) *sy = WINDOW_MINIMUM; if (*sy > WINDOW_MAXIMUM) *sy = WINDOW_MAXIMUM; log_debug("%s: resulting size is %ux%u", __func__, *sx, *sy); } static int recalculate_size_skip_client(struct client *loop, __unused int type, int current, __unused struct session *s, struct window *w) { /* * If the current flag is set, then skip any client where this window * is not the current window - this is used for aggressive-resize. * Otherwise skip any session that doesn't contain the window. */ if (loop->session->curw == NULL) return (1); if (current) return (loop->session->curw->window != w); return (session_has(loop->session, w) == 0); } void recalculate_size(struct window *w, int now) { u_int sx, sy, xpixel = 0, ypixel = 0; int type, current, changed; /* * Do not attempt to resize windows which have no pane, they must be on * the way to destruction. */ if (w->active == NULL) return; log_debug("%s: @%u is %ux%u", __func__, w->id, w->sx, w->sy); /* * Type is manual, smallest, largest, latest. Current is the * aggressive-resize option (do not resize based on clients where the * window is not the current window). */ type = options_get_number(w->options, "window-size"); current = options_get_number(w->options, "aggressive-resize"); /* Look for a suitable client and get the new size. */ changed = clients_calculate_size(type, current, NULL, NULL, w, recalculate_size_skip_client, &sx, &sy, &xpixel, &ypixel); /* * Make sure the size has actually changed. If the window has already * got a resize scheduled, then use the new size; otherwise the old. */ if (w->flags & WINDOW_RESIZE) { if (!now && changed && w->new_sx == sx && w->new_sy == sy) changed = 0; } else { if (!now && changed && w->sx == sx && w->sy == sy) changed = 0; } /* * If the size hasn't changed, update the window offset but not the * size. */ if (!changed) { log_debug("%s: @%u no size change", __func__, w->id); tty_update_window_offset(w); return; } /* * If the now flag is set or if the window is sized manually, change * the size immediately. Otherwise set the flag and it will be done * later. */ log_debug("%s: @%u new size %ux%u", __func__, w->id, sx, sy); if (now || type == WINDOW_SIZE_MANUAL) resize_window(w, sx, sy, xpixel, ypixel); else { w->new_sx = sx; w->new_sy = sy; w->new_xpixel = xpixel; w->new_ypixel = ypixel; w->flags |= WINDOW_RESIZE; tty_update_window_offset(w); } } void recalculate_sizes(void) { recalculate_sizes_now(0); } void recalculate_sizes_now(int now) { struct session *s; struct client *c; struct window *w; /* * Clear attached count and update saved status line information for * each session. */ RB_FOREACH(s, sessions, &sessions) { s->attached = 0; status_update_cache(s); } /* * Increment attached count and check the status line size for each * client. */ TAILQ_FOREACH(c, &clients, entry) { s = c->session; if (s != NULL && !(c->flags & CLIENT_UNATTACHEDFLAGS)) s->attached++; if (ignore_client_size(c)) continue; if (c->tty.sy <= s->statuslines || (c->flags & CLIENT_CONTROL)) c->flags |= CLIENT_STATUSOFF; else c->flags &= ~CLIENT_STATUSOFF; } /* Walk each window and adjust the size. */ RB_FOREACH(w, windows, &windows) recalculate_size(w, now); }