Adding upstream version 3.3a.upstream/3.3a

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 467 insertions, 0 deletions

diff --git a/resize.c b/resize.c
new file mode 100644
index 0000000..457fee0
--- /dev/null
+++ b/resize.c
@@ -0,0 +1,467 @@
+/* $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);
+
+	/* 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);
+}