circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2024-12-26 03:19:16 +00:00
Code Issues Projects Releases Wiki Activity
6d792e4123
tmux/resize.c

461 lines
12 KiB
C
Raw Normal View History

Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
/* $OpenBSD$ */
/*
I no longer use my SourceForge address so replace it.
2016-01-19 15:59:12 +00:00
* Copyright (c) 2007 Nicholas Marriott <nicholas.marriott@gmail.com>
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
*
* 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"
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
void
Make a best effort to set xpixel and ypixel for each pane and add formats for them.
2019-11-28 09:45:15 +00:00
resize_window(struct window *w, u_int sx, u_int sy, int xpixel, int ypixel)
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
{
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)
Do not notify window-layout-changed if the window is about to be destroyed (since it may have been freed by the time the notify happens), from Romain Francoise in GitHub issue 3860.
2024-03-21 11:30:42 +00:00
window_unzoom(w, 1);
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
/* 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;
Make a best effort to set xpixel and ypixel for each pane and add formats for them.
2019-11-28 09:45:15 +00:00
window_resize(w, sx, sy, xpixel, ypixel);
Improve some logging.
2021-08-25 10:18:01 +00:00
log_debug("%s: @%u resized to %ux%u; layout %ux%u", __func__, w->id,
Set the window size as well as the layout size when using the preset layouts.
2019-04-17 14:43:49 +00:00
sx, sy, w->layout_root->sx, w->layout_root->sy);
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
/* 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);
Add a window-resized hook which is fired when the window is actually resized which may be later than the client resize, GitHub issue 2995.
2022-02-17 09:58:47 +00:00
notify_window("window-resized", w);
Move lazy resize from the pane to the window, there is no point in resizing the window unless it is the current window, and if we do and don't resize the pane until later there are problems if the size changes from A to B then back to A.
2020-05-16 16:50:55 +00:00
w->flags &= ~WINDOW_RESIZE;
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
}
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Fix resizing of control clients, should be ignored until SIZECHANGED flag set.
2019-03-12 13:56:30 +00:00
static int
ignore_client_size(struct client *c)
{
If ALL clients are readonly, allow them to affect the size, suggested by Thomas Sattler.
2020-01-28 13:23:24 +00:00
struct client *loop;
Fix resizing of control clients, should be ignored until SIZECHANGED flag set.
2019-03-12 13:56:30 +00:00
if (c->session == NULL)
return (1);
if (c->flags & CLIENT_NOSIZEFLAGS)
return (1);
Change the existing client flags for control mode to apply for any client, use the same mechanism for the read-only flag and add an ignore-size flag. refresh-client -F has become -f (-F stays for backwards compatibility) and attach-session and switch-client now have -f flags also. A new format "client_flags" lists the flags and is shown by list-clients by default. This separates the read-only flag from "ignore size" behaviour (new ignore-size) flag - both behaviours are useful in different circumstances. attach -r and switchc -r remain and set or toggle both flags together.
2020-05-16 15:45:29 +00:00
if (c->flags & CLIENT_IGNORESIZE) {
If ALL clients are readonly, allow them to affect the size, suggested by Thomas Sattler.
2020-01-28 13:23:24 +00:00
/*
Change the existing client flags for control mode to apply for any client, use the same mechanism for the read-only flag and add an ignore-size flag. refresh-client -F has become -f (-F stays for backwards compatibility) and attach-session and switch-client now have -f flags also. A new format "client_flags" lists the flags and is shown by list-clients by default. This separates the read-only flag from "ignore size" behaviour (new ignore-size) flag - both behaviours are useful in different circumstances. attach -r and switchc -r remain and set or toggle both flags together.
2020-05-16 15:45:29 +00:00
* Ignore flagged clients if there are any attached clients
* that aren't flagged.
If ALL clients are readonly, allow them to affect the size, suggested by Thomas Sattler.
2020-01-28 13:23:24 +00:00
*/
TAILQ_FOREACH (loop, &clients, entry) {
if (loop->session == NULL)
continue;
if (loop->flags & CLIENT_NOSIZEFLAGS)
continue;
Change the existing client flags for control mode to apply for any client, use the same mechanism for the read-only flag and add an ignore-size flag. refresh-client -F has become -f (-F stays for backwards compatibility) and attach-session and switch-client now have -f flags also. A new format "client_flags" lists the flags and is shown by list-clients by default. This separates the read-only flag from "ignore size" behaviour (new ignore-size) flag - both behaviours are useful in different circumstances. attach -r and switchc -r remain and set or toggle both flags together.
2020-05-16 15:45:29 +00:00
if (~loop->flags & CLIENT_IGNORESIZE)
If ALL clients are readonly, allow them to affect the size, suggested by Thomas Sattler.
2020-01-28 13:23:24 +00:00
return (1);
}
}
Allow control mode clients to set a hard limit on the window width and height, GitHub issue 2594.
2021-08-27 17:15:57 +00:00
if ((c->flags & CLIENT_CONTROL) &&
(~c->flags & CLIENT_SIZECHANGED) &&
(~c->flags & CLIENT_WINDOWSIZECHANGED))
Fix resizing of control clients, should be ignored until SIZECHANGED flag set.
2019-03-12 13:56:30 +00:00
return (1);
return (0);
}
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
static u_int
clients_with_window(struct window *w)
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
{
Use the correct size for new windows when window-size is latest, reported by Vamsi Krishna Avula in GitHub issue 1917.
2019-09-23 15:41:11 +00:00
struct client *loop;
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
u_int n = 0;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
TAILQ_FOREACH(loop, &clients, entry) {
if (ignore_client_size(loop) || !session_has(loop->session, w))
continue;
if (++n > 1)
break;
}
return (n);
}
static int
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
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)
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
{
Allow control mode clients to set a hard limit on the window width and height, GitHub issue 2594.
2021-08-27 17:15:57 +00:00
struct client *loop;
struct client_window *cw;
u_int cx, cy, n = 0;
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/*
* Start comparing with 0 for largest and UINT_MAX for smallest or
* latest.
*/
Allow control mode clients to set a hard limit on the window width and height, GitHub issue 2594.
2021-08-27 17:15:57 +00:00
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;
}
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
*xpixel = *ypixel = 0;
/*
* For latest, count the number of clients with this window. We only
* care if there is more than one.
*/
Do not count client (and crash) if no window.
2021-06-10 07:29:45 +00:00
if (type == WINDOW_SIZE_LATEST && w != NULL)
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
n = clients_with_window(w);
Allow control mode clients to set a hard limit on the window width and height, GitHub issue 2594.
2021-08-27 17:15:57 +00:00
/* Skip setting the size if manual */
if (type == WINDOW_SIZE_MANUAL)
goto skip;
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/* Loop over the clients and work out the size. */
TAILQ_FOREACH(loop, &clients, entry) {
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
if (loop != c && ignore_client_size(loop)) {
Allow control mode clients to set a hard limit on the window width and height, GitHub issue 2594.
2021-08-27 17:15:57 +00:00
log_debug("%s: ignoring %s (1)", __func__, loop->name);
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
continue;
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
}
if (loop != c && skip_client(loop, type, current, s, w)) {
Allow control mode clients to set a hard limit on the window width and height, GitHub issue 2594.
2021-08-27 17:15:57 +00:00
log_debug("%s: skipping %s (1)", __func__, loop->name);
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
continue;
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
}
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/*
* If there are multiple clients attached, only accept the
* latest client; otherwise let the only client be chosen as
* for smallest.
*/
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
if (type == WINDOW_SIZE_LATEST && n > 1 && loop != w->latest) {
log_debug("%s: %s is not latest", __func__, loop->name);
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
continue;
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
}
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
Allow control mode clients to set a hard limit on the window width and height, GitHub issue 2594.
2021-08-27 17:15:57 +00:00
/*
* 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;
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/* Work out this client's size. */
Ignore windows without a size set (may be used for pane only), from Anindya Mukherjee.
2022-01-06 08:20:00 +00:00
if (cw != NULL && cw->sx != 0 && cw->sy != 0) {
Allow control mode clients to set a hard limit on the window width and height, GitHub issue 2594.
2021-08-27 17:15:57 +00:00
cx = cw->sx;
cy = cw->sy;
} else {
cx = loop->tty.sx;
cy = loop->tty.sy - status_line_size(loop);
}
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/*
* If it is larger or smaller than the best so far, update the
* new size.
*/
if (type == WINDOW_SIZE_LARGEST) {
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
if (cx > *sx)
*sx = cx;
if (cy > *sy)
*sy = cy;
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
} else {
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
if (cx < *sx)
*sx = cx;
if (cy < *sy)
*sy = cy;
}
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
if (loop->tty.xpixel > *xpixel && loop->tty.ypixel > *ypixel) {
*xpixel = loop->tty.xpixel;
*ypixel = loop->tty.ypixel;
}
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
log_debug("%s: after %s (%ux%u), size is %ux%u", __func__,
loop->name, cx, cy, *sx, *sy);
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
}
Improve some logging.
2021-08-25 10:18:01 +00:00
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__);
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
Allow control mode clients to set a hard limit on the window width and height, GitHub issue 2594.
2021-08-27 17:15:57 +00:00
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__);
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/* Return whether a suitable size was found. */
Allow control mode clients to set a hard limit on the window width and height, GitHub issue 2594.
2021-08-27 17:15:57 +00:00
if (type == WINDOW_SIZE_MANUAL) {
log_debug("%s: type is manual", __func__);
return (1);
}
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
if (type == WINDOW_SIZE_LARGEST) {
log_debug("%s: type is largest", __func__);
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
return (*sx != 0 && *sy != 0);
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
}
if (type == WINDOW_SIZE_LATEST)
log_debug("%s: type is latest", __func__);
else
log_debug("%s: type is smallest", __func__);
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
return (*sx != UINT_MAX && *sy != UINT_MAX);
}
static int
Do not check for latest client in callback since the type may be latest but with no window, fixes new-session -x and -y with another attached client. GitHub issue 4268.
2024-11-27 10:12:20 +00:00
default_window_size_skip_client(struct client *loop, __unused int type,
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
__unused int current, struct session *s, struct window *w)
{
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.
*/
Improve some logging.
2021-08-25 10:18:01 +00:00
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;
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
}
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Do not check for latest client in callback since the type may be latest but with no window, fixes new-session -x and -y with another attached client. GitHub issue 4268.
2024-11-27 10:12:20 +00:00
/*
* 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;
Ignore client creating session when working out size if it is a control client.
2021-08-25 10:15:15 +00:00
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/*
* Look for a client to base the size on. If none exists (or the type
* is manual), use the default-size option.
*/
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
if (!clients_calculate_size(type, 0, c, s, w,
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
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;
}
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
log_debug("%s: using %ux%u from default-size", __func__, *sx,
*sy);
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
}
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
done:
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/* Make sure the limits are enforced. */
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
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;
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
log_debug("%s: resulting size is %ux%u", __func__, *sx, *sy);
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
}
Cache status line position to reduce option lookups during output.
2017-02-03 21:01:02 +00:00
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
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.
*/
Do not dereference NULL window when resizing client, GitHub issue 2982.
2021-12-06 10:08:42 +00:00
if (loop->session->curw == NULL)
return (1);
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
if (current)
return (loop->session->curw->window != w);
return (session_has(loop->session, w) == 0);
}
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
void
Add support for pausing a pane when the output buffered for a control mode client gets too far behind. The pause-after flag with a time is set on the pane with refresh-client -f and a paused pane may be resumed with refresh-client -A. GitHub issue 2217.
2020-06-05 07:33:57 +00:00
recalculate_size(struct window *w, int now)
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
{
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
u_int sx, sy, xpixel = 0, ypixel = 0;
int type, current, changed;
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/*
* Do not attempt to resize windows which have no pane, they must be on
* the way to destruction.
*/
Add a "latest" window-size option which tries to size windows based on the most recently used client. From Tommie Gannert in GitHub issue 1869 based on earlier changes from me.
2019-09-19 09:02:30 +00:00
if (w->active == NULL)
return;
Improve some logging.
2021-08-25 10:18:01 +00:00
log_debug("%s: @%u is %ux%u", __func__, w->id, w->sx, w->sy);
Add a "latest" window-size option which tries to size windows based on the most recently used client. From Tommie Gannert in GitHub issue 1869 based on earlier changes from me.
2019-09-19 09:02:30 +00:00
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/*
* 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).
*/
Add a "latest" window-size option which tries to size windows based on the most recently used client. From Tommie Gannert in GitHub issue 1869 based on earlier changes from me.
2019-09-19 09:02:30 +00:00
type = options_get_number(w->options, "window-size");
current = options_get_number(w->options, "aggressive-resize");
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/* Look for a suitable client and get the new size. */
Include current client in size calculation for new sessions, GitHub issue 2662.
2021-06-10 07:24:45 +00:00
changed = clients_calculate_size(type, current, NULL, NULL, w,
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
recalculate_size_skip_client, &sx, &sy, &xpixel, &ypixel);
Add a "latest" window-size option which tries to size windows based on the most recently used client. From Tommie Gannert in GitHub issue 1869 based on earlier changes from me.
2019-09-19 09:02:30 +00:00
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/*
* Make sure the size has actually changed. If the window has already
* got a resize scheduled, then use the new size; otherwise the old.
*/
Move lazy resize from the pane to the window, there is no point in resizing the window unless it is the current window, and if we do and don't resize the pane until later there are problems if the size changes from A to B then back to A.
2020-05-16 16:50:55 +00:00
if (w->flags & WINDOW_RESIZE) {
Add support for pausing a pane when the output buffered for a control mode client gets too far behind. The pause-after flag with a time is set on the pane with refresh-client -f and a paused pane may be resumed with refresh-client -A. GitHub issue 2217.
2020-06-05 07:33:57 +00:00
if (!now && changed && w->new_sx == sx && w->new_sy == sy)
Move lazy resize from the pane to the window, there is no point in resizing the window unless it is the current window, and if we do and don't resize the pane until later there are problems if the size changes from A to B then back to A.
2020-05-16 16:50:55 +00:00
changed = 0;
} else {
Add support for pausing a pane when the output buffered for a control mode client gets too far behind. The pause-after flag with a time is set on the pane with refresh-client -f and a paused pane may be resumed with refresh-client -A. GitHub issue 2217.
2020-06-05 07:33:57 +00:00
if (!now && changed && w->sx == sx && w->sy == sy)
Move lazy resize from the pane to the window, there is no point in resizing the window unless it is the current window, and if we do and don't resize the pane until later there are problems if the size changes from A to B then back to A.
2020-05-16 16:50:55 +00:00
changed = 0;
}
Add a "latest" window-size option which tries to size windows based on the most recently used client. From Tommie Gannert in GitHub issue 1869 based on earlier changes from me.
2019-09-19 09:02:30 +00:00
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/*
* If the size hasn't changed, update the window offset but not the
* size.
*/
Add a "latest" window-size option which tries to size windows based on the most recently used client. From Tommie Gannert in GitHub issue 1869 based on earlier changes from me.
2019-09-19 09:02:30 +00:00
if (!changed) {
Improve some logging.
2021-08-25 10:18:01 +00:00
log_debug("%s: @%u no size change", __func__, w->id);
Add a "latest" window-size option which tries to size windows based on the most recently used client. From Tommie Gannert in GitHub issue 1869 based on earlier changes from me.
2019-09-19 09:02:30 +00:00
tty_update_window_offset(w);
return;
}
Tidy the resize code, merge some common bits and add some comments. From "Mike" in GitHub issue 2392.
2020-10-05 10:00:51 +00:00
/*
* 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.
*/
Improve some logging.
2021-08-25 10:18:01 +00:00
log_debug("%s: @%u new size %ux%u", __func__, w->id, sx, sy);
Add support for pausing a pane when the output buffered for a control mode client gets too far behind. The pause-after flag with a time is set on the pane with refresh-client -f and a paused pane may be resumed with refresh-client -A. GitHub issue 2217.
2020-06-05 07:33:57 +00:00
if (now || type == WINDOW_SIZE_MANUAL)
Move lazy resize from the pane to the window, there is no point in resizing the window unless it is the current window, and if we do and don't resize the pane until later there are problems if the size changes from A to B then back to A.
2020-05-16 16:50:55 +00:00
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);
}
Add a "latest" window-size option which tries to size windows based on the most recently used client. From Tommie Gannert in GitHub issue 1869 based on earlier changes from me.
2019-09-19 09:02:30 +00:00
}
void
recalculate_sizes(void)
Add support for pausing a pane when the output buffered for a control mode client gets too far behind. The pause-after flag with a time is set on the pane with refresh-client -f and a paused pane may be resumed with refresh-client -A. GitHub issue 2217.
2020-06-05 07:33:57 +00:00
{
recalculate_sizes_now(0);
}
void
recalculate_sizes_now(int now)
Add a "latest" window-size option which tries to size windows based on the most recently used client. From Tommie Gannert in GitHub issue 1869 based on earlier changes from me.
2019-09-19 09:02:30 +00:00
{
struct session *s;
struct client *c;
struct window *w;
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
/*
* Clear attached count and update saved status line information for
* each session.
*/
RB_FOREACH(s, sessions, &sessions) {
s->attached = 0;
Tidy and rename some bits of status line code.
2019-03-16 17:14:07 +00:00
status_update_cache(s);
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
}
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
/*
* Increment attached count and check the status line size for each
* client.
*/
TAILQ_FOREACH(c, &clients, entry) {
Add a define for flags meaning a client is not attached, and fix unattached counter, reported by Thomas Sattler.
2020-01-28 08:06:11 +00:00
s = c->session;
if (s != NULL && !(c->flags & CLIENT_UNATTACHEDFLAGS))
s->attached++;
Fix resizing of control clients, should be ignored until SIZECHANGED flag set.
2019-03-12 13:56:30 +00:00
if (ignore_client_size(c))
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
continue;
Do not reduce window height by status line height for control mode clients, from George Nachman.
2019-05-11 06:34:56 +00:00
if (c->tty.sy <= s->statuslines || (c->flags & CLIENT_CONTROL))
Support for windows larger than visible on the attached client. This has been a limitation for a long time. There are two new options, window-size and default-size, and a new command, resize-window. The force-width and force-height options and the session_width and session_height formats have been removed. The new window-size option tells tmux how to work out the size of windows: largest means it picks the size of the largest session, smallest the smallest session (similar to the old behaviour) and manual means that it does not automatically resize windows. The default is currently largest but this may change. aggressive-resize modifies the choice of session for largest and smallest as it did before. If a window is in a session attached to a client that is too small, only part of the window is shown. tmux attempts to keep the cursor visible, so the part of the window displayed is changed as the cursor moves (with a small delay, to try and avoid excess redrawing when applications redraw status lines or similar that are not currently visible). The offset of the visible portion of the window is shown in status-right. Drawing windows which are larger than the client is not as efficient as those which fit, particularly when the cursor moves, so it is recommended to avoid using this on slow machines or networks (set window-size to smallest or manual). The resize-window command can be used to resize a window manually. If it is used, the window-size option is automatically set to manual for the window (undo this with "setw -u window-size"). resize-window works in a similar way to resize-pane (-U -D -L -R -x -y flags) but also has -a and -A flags. -a sets the window to the size of the smallest client (what it would be if window-size was smallest) and -A the largest. For the same behaviour as force-width or force-height, use resize-window -x or -y, and "setw -u window-size" to revert to automatic sizing.. If the global window-size option is set to manual, the default-size option is used for new windows. If -x or -y is used with new-session, that sets the default-size option for the new session. The maximum size of a window is 10000x10000. But expect applications to complain and much higher memory use if making a window excessively big. The minimum size is the size required for the current layout including borders. The refresh-client command can be used to pan around a window, -U -D -L -R moves up, down, left or right and -c returns to automatic cursor tracking. The position is reset when the current window is changed.
2018-10-18 08:38:01 +00:00
c->flags |= CLIENT_STATUSOFF;
else
c->flags &= ~CLIENT_STATUSOFF;
}
/* Walk each window and adjust the size. */
Add a "latest" window-size option which tries to size windows based on the most recently used client. From Tommie Gannert in GitHub issue 1869 based on earlier changes from me.
2019-09-19 09:02:30 +00:00
RB_FOREACH(w, windows, &windows)
Add support for pausing a pane when the output buffered for a control mode client gets too far behind. The pause-after flag with a time is set on the pane with refresh-client -f and a paused pane may be resumed with refresh-client -A. GitHub issue 2217.
2020-06-05 07:33:57 +00:00
recalculate_size(w, now);
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
}
Reference in New Issue Copy Permalink