circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2024-11-16 09:28:51 +00:00
Code Issues Projects Releases Wiki Activity
b6dfb9996a
tmux/tty.c

2702 lines
65 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 <sys/ioctl.h>
Support setting the xterm clipboard when copying from copy mode using the xterm escape sequence for the purpose (if xterm is configured to allow it). Written by and much discussed Ailin Nemui, guidance on xterm/termcap/terminfo from Thomas Dickey.
2011-05-18 20:24:29 +00:00
#include <netinet/in.h>
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
#include <curses.h>
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
#include <errno.h>
#include <fcntl.h>
Support setting the xterm clipboard when copying from copy mode using the xterm escape sequence for the purpose (if xterm is configured to allow it). Written by and much discussed Ailin Nemui, guidance on xterm/termcap/terminfo from Thomas Dickey.
2011-05-18 20:24:29 +00:00
#include <resolv.h>
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
#include <stdlib.h>
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
#include <string.h>
#include <termios.h>
#include <unistd.h>
#include "tmux.h"
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int tty_log_fd = -1;
The output log is only useful once and it means creating a file, so open it once at startup instead of in every call to tty_open.
2015-10-31 13:12:03 +00:00
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
static int tty_client_ready(struct client *);
tty_client_ready can not be internal to tty.c again.
2016-04-30 18:59:02 +00:00
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void tty_set_italics(struct tty *);
static int tty_try_colour(struct tty *, int, const char *);
Add static in window-*.c and move some internal functions out of tmux.h.
2016-10-11 13:21:59 +00:00
static void tty_force_cursor_colour(struct tty *, const char *);
static void tty_cursor_pane(struct tty *, const struct tty_ctx *, u_int,
u_int);
Try to avoid moving the cursor to the start of the next line when printing cells if it is already at the very end of the line and the terminal will wrap it to the next line itself, this means terminals still see it as a wrapped line for the purposes of their own mouse selection. Reported by millert@.
2017-03-15 09:21:21 +00:00
static void tty_cursor_pane_unless_wrap(struct tty *,
const struct tty_ctx *, u_int, u_int);
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
static void tty_invalidate(struct tty *);
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void tty_colours(struct tty *, const struct grid_cell *);
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
static void tty_check_fg(struct tty *, int *, struct grid_cell *);
static void tty_check_bg(struct tty *, int *, struct grid_cell *);
static void tty_check_us(struct tty *, int *, struct grid_cell *);
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void tty_colours_fg(struct tty *, const struct grid_cell *);
static void tty_colours_bg(struct tty *, const struct grid_cell *);
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
static void tty_colours_us(struct tty *, const struct grid_cell *);
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
Add static in window-*.c and move some internal functions out of tmux.h.
2016-10-11 13:21:59 +00:00
static void tty_region_pane(struct tty *, const struct tty_ctx *, u_int,
u_int);
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
static void tty_region(struct tty *, u_int, u_int);
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
static void tty_margin_pane(struct tty *, const struct tty_ctx *);
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
static void tty_margin(struct tty *, u_int, u_int);
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int tty_large_region(struct tty *, const struct tty_ctx *);
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
static int tty_fake_bce(const struct tty *, const struct grid_cell *,
u_int);
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void tty_redraw_region(struct tty *, const struct tty_ctx *);
static void tty_emulate_repeat(struct tty *, enum tty_code_code,
enum tty_code_code, u_int);
static void tty_repeat_space(struct tty *, u_int);
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
static void tty_draw_pane(struct tty *, const struct tty_ctx *, u_int);
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
static void tty_default_attributes(struct tty *, const struct grid_cell *,
int *, u_int);
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
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
#define tty_use_margin(tty) \
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
(tty->term->flags & TERM_DECSLRM)
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
#define tty_full_width(tty, ctx) \
((ctx)->xoff == 0 && (ctx)->sx >= (tty)->sx)
Tidy up by adding a macro for the pane being the full screen width, from Ailin Nemui.
2012-05-05 18:45:55 +00:00
When the data we have buffered to write to a terminal grows beyond a reasonable amount (currently width * height * 8 bytes), discard all output to the terminal and start trying to redraw periodically instead. Continue with this until the amount of data we are trying to write falls to a low level again. This helps to prevent tmux sitting on a huge buffer of data when there are processes with fast output running inside tmux but the outside terminal is slow. A new client_discarded format holds the amount of data that has been discarded due to this mechanism. The three variables (when to start this, when to stop, and how often to redraw) are basically "works for me" at the moment, this is going in to see how it goes and if it causes problems for anyone else.
2017-04-19 06:52:27 +00:00
#define TTY_BLOCK_INTERVAL (100000 /* 100 milliseconds */)
#define TTY_BLOCK_START(tty) (1 + ((tty)->sx * (tty)->sy) * 8)
#define TTY_BLOCK_STOP(tty) (1 + ((tty)->sx * (tty)->sy) / 8)
The output log is only useful once and it means creating a file, so open it once at startup instead of in every call to tty_open.
2015-10-31 13:12:03 +00:00
void
tty_create_log(void)
{
char name[64];
xsnprintf(name, sizeof name, "tmux-out-%ld.log", (long)getpid());
tty_log_fd = open(name, O_WRONLY|O_CREAT|O_TRUNC, 0644);
if (tty_log_fd != -1 && fcntl(tty_log_fd, F_SETFD, FD_CLOEXEC) == -1)
fatal("fcntl failed");
}
Fix line endings.
2015-07-13 15:51:31 +00:00
int
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
tty_init(struct tty *tty, struct client *c)
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
{
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
if (!isatty(c->fd))
Fix line endings.
2015-07-13 15:51:31 +00:00
return (-1);
Don't attempt to open() the tty path, rely on the client sending its stdin fd with imsg and fatal if it doesn't, then set the FD_CLOEXEC flag in tty_init instead of tty_open to prevent them leaking into child processes if any are created between the two calls. This bumps the protocol version, so the tmux server should be killed before upgrading.
2009-09-23 06:05:02 +00:00
memset(tty, 0, sizeof *tty);
Store client in tty struct directly instead of using a callback function pointer.
2012-05-22 14:32:28 +00:00
tty->client = c;
Don't attempt to open() the tty path, rely on the client sending its stdin fd with imsg and fatal if it doesn't, then set the FD_CLOEXEC flag in tty_init instead of tty_open to prevent them leaking into child processes if any are created between the two calls. This bumps the protocol version, so the tmux server should be killed before upgrading.
2009-09-23 06:05:02 +00:00
Support DECSCUSR sequence to set the cursor style with two new terminfo(5) extensions, Cs and Csr. Written by Ailin Nemui.
2011-05-20 19:17:39 +00:00
tty->cstyle = 0;
Support xterm(1) cursor colour change sequences through terminfo(5) Cc (set) and Cr (reset) extensions. Originally by Sean Estabrooks, tweaked by me and Ailin Nemui.
2011-05-20 19:03:58 +00:00
tty->ccolour = xstrdup("");
Don't attempt to open() the tty path, rely on the client sending its stdin fd with imsg and fatal if it doesn't, then set the FD_CLOEXEC flag in tty_init instead of tty_open to prevent them leaking into child processes if any are created between the two calls. This bumps the protocol version, so the tmux server should be killed before upgrading.
2009-09-23 06:05:02 +00:00
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
if (tcgetattr(c->fd, &tty->tio) != 0)
return (-1);
Fix line endings.
2015-07-13 15:51:31 +00:00
return (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
}
It is not OK to ignore SIGWINCH if SIOCGWINSZ reports the size has unchanged, because it may have changed and changed back in the time between us getting the signal and calling ioctl(). Always redraw when we see SIGWINCH.
2017-05-31 10:29:15 +00:00
void
Trim some code by moving the ioctl(TIOCGWINSZ) after SIGWINCH from the client into the server. This is another (the second of four) protocol version changes coming this morning, so again the server should be killed before upgrading.
2009-09-23 06:12:58 +00:00
tty_resize(struct tty *tty)
{
Give each client a name. This defaults to the tty name as before but falls back to an alternative if the tty name is not available. This is clearer than overloading the client ttyname member and allows us to remove the path stored in the tty struct, it should always be the same as the client.
2017-04-05 10:49:46 +00:00
struct client *c = tty->client;
struct winsize ws;
Store xpixel/ypixel from TIOCGWINSZ and add formats.
2019-11-28 09:05:34 +00:00
u_int sx, sy, xpixel, ypixel;
Trim some code by moving the ioctl(TIOCGWINSZ) after SIGWINCH from the client into the server. This is another (the second of four) protocol version changes coming this morning, so again the server should be killed before upgrading.
2009-09-23 06:12:58 +00:00
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
if (ioctl(c->fd, TIOCGWINSZ, &ws) != -1) {
Fix problems with window sizing seen by Raghavendra D Prabhu when starting tmux from .xinitrc. One of the very few things the server relies on the client for now is to pass through a message on SIGWINCH, but there is a condition where potentially a SIGWINCH may be lost during the transition from unattached (main.c) to attached (client.c). So trigger a size change immediately after the client installs its SIGWINCH handler. Also, when the terminal is resized, reset the scroll region and cursor position. Previously, we were clearing our saved idea of these, but in fact some terminals do not reset them on resize, so this caused problems during redraw. While here make a resize to the same size not cause a redraw and rename the tmux.out output log file to include the tmux PID.
2010-06-05 16:47:11 +00:00
sx = ws.ws_col;
Store xpixel/ypixel from TIOCGWINSZ and add formats.
2019-11-28 09:05:34 +00:00
if (sx == 0) {
Fix problems with window sizing seen by Raghavendra D Prabhu when starting tmux from .xinitrc. One of the very few things the server relies on the client for now is to pass through a message on SIGWINCH, but there is a condition where potentially a SIGWINCH may be lost during the transition from unattached (main.c) to attached (client.c). So trigger a size change immediately after the client installs its SIGWINCH handler. Also, when the terminal is resized, reset the scroll region and cursor position. Previously, we were clearing our saved idea of these, but in fact some terminals do not reset them on resize, so this caused problems during redraw. While here make a resize to the same size not cause a redraw and rename the tmux.out output log file to include the tmux PID.
2010-06-05 16:47:11 +00:00
sx = 80;
Store xpixel/ypixel from TIOCGWINSZ and add formats.
2019-11-28 09:05:34 +00:00
xpixel = 0;
} else
xpixel = ws.ws_xpixel / sx;
Fix problems with window sizing seen by Raghavendra D Prabhu when starting tmux from .xinitrc. One of the very few things the server relies on the client for now is to pass through a message on SIGWINCH, but there is a condition where potentially a SIGWINCH may be lost during the transition from unattached (main.c) to attached (client.c). So trigger a size change immediately after the client installs its SIGWINCH handler. Also, when the terminal is resized, reset the scroll region and cursor position. Previously, we were clearing our saved idea of these, but in fact some terminals do not reset them on resize, so this caused problems during redraw. While here make a resize to the same size not cause a redraw and rename the tmux.out output log file to include the tmux PID.
2010-06-05 16:47:11 +00:00
sy = ws.ws_row;
Store xpixel/ypixel from TIOCGWINSZ and add formats.
2019-11-28 09:05:34 +00:00
if (sy == 0) {
Fix problems with window sizing seen by Raghavendra D Prabhu when starting tmux from .xinitrc. One of the very few things the server relies on the client for now is to pass through a message on SIGWINCH, but there is a condition where potentially a SIGWINCH may be lost during the transition from unattached (main.c) to attached (client.c). So trigger a size change immediately after the client installs its SIGWINCH handler. Also, when the terminal is resized, reset the scroll region and cursor position. Previously, we were clearing our saved idea of these, but in fact some terminals do not reset them on resize, so this caused problems during redraw. While here make a resize to the same size not cause a redraw and rename the tmux.out output log file to include the tmux PID.
2010-06-05 16:47:11 +00:00
sy = 24;
Store xpixel/ypixel from TIOCGWINSZ and add formats.
2019-11-28 09:05:34 +00:00
ypixel = 0;
} else
ypixel = ws.ws_ypixel / sy;
Fix problems with window sizing seen by Raghavendra D Prabhu when starting tmux from .xinitrc. One of the very few things the server relies on the client for now is to pass through a message on SIGWINCH, but there is a condition where potentially a SIGWINCH may be lost during the transition from unattached (main.c) to attached (client.c). So trigger a size change immediately after the client installs its SIGWINCH handler. Also, when the terminal is resized, reset the scroll region and cursor position. Previously, we were clearing our saved idea of these, but in fact some terminals do not reset them on resize, so this caused problems during redraw. While here make a resize to the same size not cause a redraw and rename the tmux.out output log file to include the tmux PID.
2010-06-05 16:47:11 +00:00
} else {
sx = 80;
sy = 24;
Store xpixel/ypixel from TIOCGWINSZ and add formats.
2019-11-28 09:05:34 +00:00
xpixel = 0;
ypixel = 0;
Trim some code by moving the ioctl(TIOCGWINSZ) after SIGWINCH from the client into the server. This is another (the second of four) protocol version changes coming this morning, so again the server should be killed before upgrading.
2009-09-23 06:12:58 +00:00
}
Store xpixel/ypixel from TIOCGWINSZ and add formats.
2019-11-28 09:05:34 +00:00
log_debug("%s: %s now %ux%u (%ux%u)", __func__, c->name, sx, sy,
xpixel, ypixel);
tty_set_size(tty, sx, sy, xpixel, ypixel);
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
tty_invalidate(tty);
Trim some code by moving the ioctl(TIOCGWINSZ) after SIGWINCH from the client into the server. This is another (the second of four) protocol version changes coming this morning, so again the server should be killed before upgrading.
2009-09-23 06:12:58 +00:00
}
It is not OK to ignore SIGWINCH if SIOCGWINSZ reports the size has unchanged, because it may have changed and changed back in the time between us getting the signal and calling ioctl(). Always redraw when we see SIGWINCH.
2017-05-31 10:29:15 +00:00
void
Store xpixel/ypixel from TIOCGWINSZ and add formats.
2019-11-28 09:05:34 +00:00
tty_set_size(struct tty *tty, u_int sx, u_int sy, u_int xpixel, u_int ypixel)
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
{
Add a wrapper function tty_set_size from George Nachman.
2012-02-15 17:25:02 +00:00
tty->sx = sx;
tty->sy = sy;
Store xpixel/ypixel from TIOCGWINSZ and add formats.
2019-11-28 09:05:34 +00:00
tty->xpixel = xpixel;
tty->ypixel = ypixel;
Add a wrapper function tty_set_size from George Nachman.
2012-02-15 17:25:02 +00:00
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
tty_read_callback(__unused int fd, __unused short events, void *data)
Switch tty key input over to happen on a read event. This is a bit more complicated because of escape input, but in that case instead of processing a key immediately, schedule a timer and reprocess the bufer when it expires. This currently assumes that keys will be atomic (ie that if eg F1 is pressed the entire sequence is present in the buffer). This is usually but not always true, a change in the tree format so it can differentiate potential (partial) key sequences will happens soon and will allow this to be fixed.
2009-11-05 08:45:08 +00:00
{
struct tty *tty = data;
Give each client a name. This defaults to the tty name as before but falls back to an alternative if the tty name is not available. This is clearer than overloading the client ttyname member and allows us to remove the path stored in the tty struct, it should always be the same as the client.
2017-04-05 10:49:46 +00:00
struct client *c = tty->client;
Add a -D flag to ask tmux not to daemonize, useful both for running a debugger (lldb does not have follow-fork-mode) and for running with a managed supervisor init system. GitHub issue 2190.
2020-05-16 16:07:55 +00:00
const char *name = c->name;
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
size_t size = EVBUFFER_LENGTH(tty->in);
int nread;
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
nread = evbuffer_read(tty->in, c->fd, -1);
When tty is error or closed, remove client. Reported by Thomas Sattler.
2017-08-24 08:48:37 +00:00
if (nread == 0 || nread == -1) {
Add a -D flag to ask tmux not to daemonize, useful both for running a debugger (lldb does not have follow-fork-mode) and for running with a managed supervisor init system. GitHub issue 2190.
2020-05-16 16:07:55 +00:00
if (nread == 0)
log_debug("%s: read closed", name);
else
log_debug("%s: read error: %s", name, strerror(errno));
Delete input event when evbuffer_read() fails to avoid just spinning around a dead file descriptor. Seems to fix a problem reported by Greg Hurrell in GitHub issue 941.
2017-06-06 14:53:28 +00:00
event_del(&tty->event_in);
When tty is error or closed, remove client. Reported by Thomas Sattler.
2017-08-24 08:48:37 +00:00
server_client_lost(tty->client);
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
return;
Delete input event when evbuffer_read() fails to avoid just spinning around a dead file descriptor. Seems to fix a problem reported by Greg Hurrell in GitHub issue 941.
2017-06-06 14:53:28 +00:00
}
Add a -D flag to ask tmux not to daemonize, useful both for running a debugger (lldb does not have follow-fork-mode) and for running with a managed supervisor init system. GitHub issue 2190.
2020-05-16 16:07:55 +00:00
log_debug("%s: read %d bytes (already %zu)", name, nread, size);
Switch tty key input over to happen on a read event. This is a bit more complicated because of escape input, but in that case instead of processing a key immediately, schedule a timer and reprocess the bufer when it expires. This currently assumes that keys will be atomic (ie that if eg F1 is pressed the entire sequence is present in the buffer). This is usually but not always true, a change in the tree format so it can differentiate potential (partial) key sequences will happens soon and will allow this to be fixed.
2009-11-05 08:45:08 +00:00
while (tty_keys_next(tty))
;
}
When the data we have buffered to write to a terminal grows beyond a reasonable amount (currently width * height * 8 bytes), discard all output to the terminal and start trying to redraw periodically instead. Continue with this until the amount of data we are trying to write falls to a low level again. This helps to prevent tmux sitting on a huge buffer of data when there are processes with fast output running inside tmux but the outside terminal is slow. A new client_discarded format holds the amount of data that has been discarded due to this mechanism. The three variables (when to start this, when to stop, and how often to redraw) are basically "works for me" at the moment, this is going in to see how it goes and if it causes problems for anyone else.
2017-04-19 06:52:27 +00:00
static void
tty_timer_callback(__unused int fd, __unused short events, void *data)
{
struct tty *tty = data;
struct client *c = tty->client;
struct timeval tv = { .tv_usec = TTY_BLOCK_INTERVAL };
log_debug("%s: %zu discarded", c->name, tty->discarded);
Add a client redraw-window flag instead of the redraw-all flag and for all just use the three flags together (window, borders, status).
2018-08-19 16:45:03 +00:00
c->flags |= CLIENT_ALLREDRAWFLAGS;
When the data we have buffered to write to a terminal grows beyond a reasonable amount (currently width * height * 8 bytes), discard all output to the terminal and start trying to redraw periodically instead. Continue with this until the amount of data we are trying to write falls to a low level again. This helps to prevent tmux sitting on a huge buffer of data when there are processes with fast output running inside tmux but the outside terminal is slow. A new client_discarded format holds the amount of data that has been discarded due to this mechanism. The three variables (when to start this, when to stop, and how often to redraw) are basically "works for me" at the moment, this is going in to see how it goes and if it causes problems for anyone else.
2017-04-19 06:52:27 +00:00
c->discarded += tty->discarded;
if (tty->discarded < TTY_BLOCK_STOP(tty)) {
tty->flags &= ~TTY_BLOCK;
tty_invalidate(tty);
return;
}
tty->discarded = 0;
evtimer_add(&tty->timer, &tv);
}
static int
tty_block_maybe(struct tty *tty)
{
struct client *c = tty->client;
size_t size = EVBUFFER_LENGTH(tty->out);
struct timeval tv = { .tv_usec = TTY_BLOCK_INTERVAL };
if (size < TTY_BLOCK_START(tty))
return (0);
if (tty->flags & TTY_BLOCK)
return (1);
tty->flags |= TTY_BLOCK;
log_debug("%s: can't keep up, %zu discarded", c->name, size);
evbuffer_drain(tty->out, size);
c->discarded += size;
tty->discarded = 0;
evtimer_add(&tty->timer, &tv);
return (1);
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
tty_write_callback(__unused int fd, __unused short events, void *data)
Switch tty fds over to a bufferevent.
2009-11-04 21:47:42 +00:00
{
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
struct tty *tty = data;
Give each client a name. This defaults to the tty name as before but falls back to an alternative if the tty name is not available. This is clearer than overloading the client ttyname member and allows us to remove the path stored in the tty struct, it should always be the same as the client.
2017-04-05 10:49:46 +00:00
struct client *c = tty->client;
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
size_t size = EVBUFFER_LENGTH(tty->out);
int nwrite;
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
nwrite = evbuffer_write(tty->out, c->fd);
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
if (nwrite == -1)
return;
Give each client a name. This defaults to the tty name as before but falls back to an alternative if the tty name is not available. This is clearer than overloading the client ttyname member and allows us to remove the path stored in the tty struct, it should always be the same as the client.
2017-04-05 10:49:46 +00:00
log_debug("%s: wrote %d bytes (of %zu)", c->name, nwrite, size);
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
If the current screen was complex enough, it was possible to make redraw itself hit the "terminal can't keep up" check. To avoid this, record how much data we send during redraw (we know we will be starting with 0) and skip the check until it has been flushed. GitHub issue 912.
2017-05-09 13:04:36 +00:00
if (c->redraw > 0) {
if ((size_t)nwrite >= c->redraw)
c->redraw = 0;
else
c->redraw -= nwrite;
log_debug("%s: waiting for redraw, %zu bytes left", c->name,
c->redraw);
} else if (tty_block_maybe(tty))
When the data we have buffered to write to a terminal grows beyond a reasonable amount (currently width * height * 8 bytes), discard all output to the terminal and start trying to redraw periodically instead. Continue with this until the amount of data we are trying to write falls to a low level again. This helps to prevent tmux sitting on a huge buffer of data when there are processes with fast output running inside tmux but the outside terminal is slow. A new client_discarded format holds the amount of data that has been discarded due to this mechanism. The three variables (when to start this, when to stop, and how often to redraw) are basically "works for me" at the moment, this is going in to see how it goes and if it causes problems for anyone else.
2017-04-19 06:52:27 +00:00
return;
Add not delete the event if more to write.
2017-02-10 15:39:43 +00:00
if (EVBUFFER_LENGTH(tty->out) != 0)
event_add(&tty->event_out, NULL);
Switch tty fds over to a bufferevent.
2009-11-04 21:47:42 +00:00
}
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
int
tty_open(struct tty *tty, char **cause)
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 up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
struct client *c = tty->client;
Move the call to setupterm() into the client and have it pass the results to the server over imsg, means the server does not need to enter ncurses or read terminfo db. Old clients will not work with a new server.
2021-02-17 07:18:36 +00:00
tty->term = tty_term_create(tty, c->term_name, c->term_caps,
c->term_ncaps, &c->term_features, cause);
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
if (tty->term == NULL) {
tty_close(tty);
return (-1);
}
tty->flags |= TTY_OPENED;
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
When the data we have buffered to write to a terminal grows beyond a reasonable amount (currently width * height * 8 bytes), discard all output to the terminal and start trying to redraw periodically instead. Continue with this until the amount of data we are trying to write falls to a low level again. This helps to prevent tmux sitting on a huge buffer of data when there are processes with fast output running inside tmux but the outside terminal is slow. A new client_discarded format holds the amount of data that has been discarded due to this mechanism. The three variables (when to start this, when to stop, and how often to redraw) are basically "works for me" at the moment, this is going in to see how it goes and if it causes problems for anyone else.
2017-04-19 06:52:27 +00:00
tty->flags &= ~(TTY_NOCURSOR|TTY_FREEZE|TTY_BLOCK|TTY_TIMER);
Don't die if the client is detaching (the tty has been closed) after waking up from locking.
2009-09-23 07:25:31 +00:00
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
event_set(&tty->event_in, c->fd, EV_PERSIST|EV_READ,
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
tty_read_callback, tty);
tty->in = evbuffer_new();
evbuffer_new and bufferevent_new can both fail (when malloc fails) and return NULL. GitHub issue 1547.
2018-11-19 13:35:40 +00:00
if (tty->in == NULL)
fatal("out of memory");
Support -c like sh(1) to execute a command, useful when tmux is a login shell. Suggested by halex@. This includes another protocol version increase (the last for now) so again restart the tmux server before upgrading.
2009-09-23 12:03:30 +00:00
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
event_set(&tty->event_out, c->fd, EV_WRITE, tty_write_callback, tty);
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
tty->out = evbuffer_new();
evbuffer_new and bufferevent_new can both fail (when malloc fails) and return NULL. GitHub issue 1547.
2018-11-19 13:35:40 +00:00
if (tty->out == NULL)
fatal("out of memory");
Switch tty fds over to a bufferevent.
2009-11-04 21:47:42 +00:00
When the data we have buffered to write to a terminal grows beyond a reasonable amount (currently width * height * 8 bytes), discard all output to the terminal and start trying to redraw periodically instead. Continue with this until the amount of data we are trying to write falls to a low level again. This helps to prevent tmux sitting on a huge buffer of data when there are processes with fast output running inside tmux but the outside terminal is slow. A new client_discarded format holds the amount of data that has been discarded due to this mechanism. The three variables (when to start this, when to stop, and how often to redraw) are basically "works for me" at the moment, this is going in to see how it goes and if it causes problems for anyone else.
2017-04-19 06:52:27 +00:00
evtimer_set(&tty->timer, tty_timer_callback, tty);
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
tty_start_tty(tty);
tty_keys_build(tty);
return (0);
Break out termios initialization into a separate function, from George Nachman.
2012-03-17 21:27:51 +00:00
}
Stop handling DA and DSR after a second (they should be the first thing sent) so this should be plenty.
2020-01-13 11:59:21 +00:00
static void
tty_start_timer_callback(__unused int fd, __unused short events, void *data)
{
struct tty *tty = data;
struct client *c = tty->client;
log_debug("%s: start timer fired", c->name);
Add a terminal feature for enable/disable extended keys (supported by xterm and mintty) and add an option to make tmux send it. Only forward extended keys if the application has requested them, even though we use the CSI u sequence and xterm uses CSI 27 ~ - this is what mintty does as well.
2020-05-16 16:44:54 +00:00
if ((tty->flags & (TTY_HAVEDA|TTY_HAVEXDA)) == 0)
tty_update_features(tty);
Remove support for iTerm2's DSR 1337 extension and use the CSI > q extension now supported by a few different terminals.
2020-05-16 14:16:25 +00:00
tty->flags |= (TTY_HAVEDA|TTY_HAVEXDA);
Stop handling DA and DSR after a second (they should be the first thing sent) so this should be plenty.
2020-01-13 11:59:21 +00:00
}
Break out termios initialization into a separate function, from George Nachman.
2012-03-17 21:27:51 +00:00
void
tty_start_tty(struct tty *tty)
{
Check the terminfo(5) U8 capability and disable using UTF-8 for ACS if it is present and zero. This is useful for users with terminals or fonts that do not correctly support UTF-8 line drawing characters. GitHub issue 927, reported by Hiroaki Yamazoe and Akinori Hattori.
2017-05-15 16:44:04 +00:00
struct client *c = tty->client;
struct termios tio;
Stop handling DA and DSR after a second (they should be the first thing sent) so this should be plenty.
2020-01-13 11:59:21 +00:00
struct timeval tv = { .tv_sec = 1 };
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
setblocking(c->fd, 0);
event_add(&tty->event_in, NULL);
memcpy(&tio, &tty->tio, sizeof tio);
tio.c_iflag &= ~(IXON|IXOFF|ICRNL|INLCR|IGNCR|IMAXBEL|ISTRIP);
tio.c_iflag |= IGNBRK;
tio.c_oflag &= ~(OPOST|ONLCR|OCRNL|ONLRET);
tio.c_lflag &= ~(IEXTEN|ICANON|ECHO|ECHOE|ECHONL|ECHOCTL|ECHOPRT|
ECHOKE|ISIG);
tio.c_cc[VMIN] = 1;
tio.c_cc[VTIME] = 0;
if (tcsetattr(c->fd, TCSANOW, &tio) == 0)
tcflush(c->fd, TCIOFLUSH);
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
tty_putcode(tty, TTYC_SMCUP);
Don't send initialisation strings is1/2/3 (barely anything else does) and move smcup to the first and rmcup to the last sequences output to the terminal. This allows tmux to use the alternate screen (smcup/rmcup) when available.
2009-07-10 07:11:59 +00:00
Always send smkx to the terminal outside, the keys we get from terminfo are the keys when it is on.
2017-03-08 14:34:35 +00:00
tty_putcode(tty, TTYC_SMKX);
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
tty_putcode(tty, TTYC_CLEAR);
Check the terminfo(5) U8 capability and disable using UTF-8 for ACS if it is present and zero. This is useful for users with terminals or fonts that do not correctly support UTF-8 line drawing characters. GitHub issue 927, reported by Hiroaki Yamazoe and Akinori Hattori.
2017-05-15 16:44:04 +00:00
if (tty_acs_needed(tty)) {
log_debug("%s: using capabilities for ACS", c->name);
tty_putcode(tty, TTYC_ENACS);
} else
log_debug("%s: using UTF-8 for ACS", c->name);
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
tty_putcode(tty, TTYC_CNORM);
Turn off mouse mode 1003 as well as the rest when exiting.
2020-03-16 09:18:47 +00:00
if (tty_term_has(tty->term, TTYC_KMOUS)) {
tty_puts(tty, "\033[?1000l\033[?1002l\033[?1003l");
tty_puts(tty, "\033[?1006l\033[?1005l");
}
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
Stop handling DA and DSR after a second (they should be the first thing sent) so this should be plenty.
2020-01-13 11:59:21 +00:00
evtimer_set(&tty->start_timer, tty_start_timer_callback, tty);
evtimer_add(&tty->start_timer, &tv);
Drop the no_stop argument to tty_close and tty_free in favour of a flag in the tty struct.
2009-08-11 19:32:25 +00:00
tty->flags |= TTY_STARTED;
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
tty_invalidate(tty);
Support xterm(1) cursor colour change sequences through terminfo(5) Cc (set) and Cr (reset) extensions. Originally by Sean Estabrooks, tweaked by me and Ailin Nemui.
2011-05-20 19:03:58 +00:00
Do not set cursor colour to default unless it has been changed, GitHub issue 2013.
2019-12-11 12:13:37 +00:00
if (*tty->ccolour != '\0')
tty_force_cursor_colour(tty, "");
Rewrite of tmux mouse support which was a mess. Instead of having options for "mouse-this" and "mouse-that", mouse events may be bound as keys and there is one option "mouse" that turns on mouse support entirely (set -g mouse on). See the new MOUSE SUPPORT section of the man page for description of the key names and new flags (-t= to specify the pane or window under mouse as a target, and send-keys -M to pass through a mouse event). The default builtin bindings for the mouse are: bind -n MouseDown1Pane select-pane -t=; send-keys -M bind -n MouseDown1Status select-window -t= bind -n MouseDrag1Pane copy-mode -M bind -n MouseDrag1Border resize-pane -M To get the effect of turning mode-mouse off, do: unbind -n MouseDrag1Pane unbind -temacs-copy MouseDrag1Pane The old mouse options are now gone, set-option -q may be used to suppress warnings if mixing configuration files.
2015-04-19 21:34:21 +00:00
tty->mouse_drag_flag = 0;
tty->mouse_drag_update = NULL;
tty->mouse_drag_release = NULL;
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
}
Wait until the initial command sequence is done before sending a device attributes request and other bits that prompt a reply from the terminal. This means that stray relies are not left on the terminal if the command has attached and then immediately detached and tmux will not be around to receive them. Prompted by a problem report from espie@.
2020-04-09 12:16:16 +00:00
void
tty_send_requests(struct tty *tty)
{
if (~tty->flags & TTY_STARTED)
return;
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
if (tty->term->flags & TERM_VT100LIKE) {
Wait until the initial command sequence is done before sending a device attributes request and other bits that prompt a reply from the terminal. This means that stray relies are not left on the terminal if the command has attached and then immediately detached and tmux will not be around to receive them. Prompted by a problem report from espie@.
2020-04-09 12:16:16 +00:00
if (~tty->flags & TTY_HAVEDA)
Send secondary device attributes instead of primary which gives us a bit more useful information on some terminals.
2020-04-16 15:14:25 +00:00
tty_puts(tty, "\033[>c");
Remove support for iTerm2's DSR 1337 extension and use the CSI > q extension now supported by a few different terminals.
2020-05-16 14:16:25 +00:00
if (~tty->flags & TTY_HAVEXDA)
tty_puts(tty, "\033[>q");
Wait until the initial command sequence is done before sending a device attributes request and other bits that prompt a reply from the terminal. This means that stray relies are not left on the terminal if the command has attached and then immediately detached and tmux will not be around to receive them. Prompted by a problem report from espie@.
2020-04-09 12:16:16 +00:00
} else
Remove support for iTerm2's DSR 1337 extension and use the CSI > q extension now supported by a few different terminals.
2020-05-16 14:16:25 +00:00
tty->flags |= (TTY_HAVEDA|TTY_HAVEXDA);
Wait until the initial command sequence is done before sending a device attributes request and other bits that prompt a reply from the terminal. This means that stray relies are not left on the terminal if the command has attached and then immediately detached and tmux will not be around to receive them. Prompted by a problem report from espie@.
2020-04-09 12:16:16 +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
void
tty_stop_tty(struct tty *tty)
{
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
struct client *c = tty->client;
struct winsize ws;
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
Drop the no_stop argument to tty_close and tty_free in favour of a flag in the tty struct.
2009-08-11 19:32:25 +00:00
if (!(tty->flags & TTY_STARTED))
return;
tty->flags &= ~TTY_STARTED;
Stop handling DA and DSR after a second (they should be the first thing sent) so this should be plenty.
2020-01-13 11:59:21 +00:00
evtimer_del(&tty->start_timer);
When the data we have buffered to write to a terminal grows beyond a reasonable amount (currently width * height * 8 bytes), discard all output to the terminal and start trying to redraw periodically instead. Continue with this until the amount of data we are trying to write falls to a low level again. This helps to prevent tmux sitting on a huge buffer of data when there are processes with fast output running inside tmux but the outside terminal is slow. A new client_discarded format holds the amount of data that has been discarded due to this mechanism. The three variables (when to start this, when to stop, and how often to redraw) are basically "works for me" at the moment, this is going in to see how it goes and if it causes problems for anyone else.
2017-04-19 06:52:27 +00:00
event_del(&tty->timer);
tty->flags &= ~TTY_BLOCK;
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
event_del(&tty->event_in);
event_del(&tty->event_out);
Switch tty fds over to a bufferevent.
2009-11-04 21:47:42 +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
/*
* Be flexible about error handling and try not kill the server just
* because the fd is invalid. Things like ssh -t can easily leave us
* with a dead tty.
*/
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
if (ioctl(c->fd, TIOCGWINSZ, &ws) == -1)
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
return;
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
if (tcsetattr(c->fd, TCSANOW, &tty->tio) == -1)
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
return;
tty_raw(tty, tty_term_string2(tty->term, TTYC_CSR, 0, ws.ws_row - 1));
Check the terminfo(5) U8 capability and disable using UTF-8 for ACS if it is present and zero. This is useful for users with terminals or fonts that do not correctly support UTF-8 line drawing characters. GitHub issue 927, reported by Hiroaki Yamazoe and Akinori Hattori.
2017-05-15 16:44:04 +00:00
if (tty_acs_needed(tty))
Use UTF-8 line drawing characters on UTF-8 terminals. Fixes some stupid terminals (I'm looking at you, putty) which disable the vt100 ACS mode switching sequences in UTF-8 mode. Also on terminals without ACS at all, use ASCII equivalents where obvious.
2010-09-11 16:19:22 +00:00
tty_raw(tty, tty_term_string(tty->term, TTYC_RMACS));
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
tty_raw(tty, tty_term_string(tty->term, TTYC_SGR0));
tty_raw(tty, tty_term_string(tty->term, TTYC_RMKX));
tty_raw(tty, tty_term_string(tty->term, TTYC_CLEAR));
The actual terminfo entries we ended up with for cursor changes are Cs, Ce, Ss and Se (not Cc, Ce, Cs, Csr). So use and document these instead of the ones we were using earlier.
2013-06-02 07:52:15 +00:00
if (tty_term_has(tty->term, TTYC_SS) && tty->cstyle != 0) {
if (tty_term_has(tty->term, TTYC_SE))
tty_raw(tty, tty_term_string(tty->term, TTYC_SE));
Trim another useless if statement, from Ailin Nemui.
2011-05-26 07:08:48 +00:00
else
The actual terminfo entries we ended up with for cursor changes are Cs, Ce, Ss and Se (not Cc, Ce, Cs, Csr). So use and document these instead of the ones we were using earlier.
2013-06-02 07:52:15 +00:00
tty_raw(tty, tty_term_string1(tty->term, TTYC_SS, 0));
Support DECSCUSR sequence to set the cursor style with two new terminfo(5) extensions, Cs and Csr. Written by Ailin Nemui.
2011-05-20 19:17:39 +00:00
}
Reset bracket paste mode on detach.
2015-02-05 11:46:57 +00:00
if (tty->mode & MODE_BRACKETPASTE)
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
tty_raw(tty, tty_term_string(tty->term, TTYC_DSBP));
Do not set cursor colour to default unless it has been changed, GitHub issue 2013.
2019-12-11 12:13:37 +00:00
if (*tty->ccolour != '\0')
tty_raw(tty, tty_term_string(tty->term, TTYC_CR));
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
tty_raw(tty, tty_term_string(tty->term, TTYC_CNORM));
Turn off mouse mode 1003 as well as the rest when exiting.
2020-03-16 09:18:47 +00:00
if (tty_term_has(tty->term, TTYC_KMOUS)) {
tty_raw(tty, "\033[?1000l\033[?1002l\033[?1003l");
tty_raw(tty, "\033[?1006l\033[?1005l");
}
Correctly handle UTF8 mouse option being toggled, from Egmont Koblinger.
2013-03-22 10:34:46 +00:00
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
if (tty->term->flags & TERM_VT100LIKE)
tty_raw(tty, "\033[?7727l");
Add a terminal feature for enable/disable extended keys (supported by xterm and mintty) and add an option to make tmux send it. Only forward extended keys if the application has requested them, even though we use the CSI u sequence and xterm uses CSI 27 ~ - this is what mintty does as well.
2020-05-16 16:44:54 +00:00
tty_raw(tty, tty_term_string(tty->term, TTYC_DSFCS));
tty_raw(tty, tty_term_string(tty->term, TTYC_DSEKS));
Don't send initialisation strings is1/2/3 (barely anything else does) and move smcup to the first and rmcup to the last sequences output to the terminal. This allows tmux to use the alternate screen (smcup/rmcup) when available.
2009-07-10 07:11:59 +00:00
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
if (tty_use_margin(tty))
Add extension terminfo(5) capabilities for margins.
2020-05-16 14:22:51 +00:00
tty_raw(tty, tty_term_string(tty->term, TTYC_DSMG));
Don't send initialisation strings is1/2/3 (barely anything else does) and move smcup to the first and rmcup to the last sequences output to the terminal. This allows tmux to use the alternate screen (smcup/rmcup) when available.
2009-07-10 07:11:59 +00:00
tty_raw(tty, tty_term_string(tty->term, TTYC_RMCUP));
Correctly handle UTF8 mouse option being toggled, from Egmont Koblinger.
2013-03-22 10:34:46 +00:00
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
setblocking(c->fd, 1);
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
}
void
Drop the no_stop argument to tty_close and tty_free in favour of a flag in the tty struct.
2009-08-11 19:32:25 +00:00
tty_close(struct tty *tty)
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
{
Check event_initialized before event_del if event may not have been set up; libevent2 complains about this. Reported by Moriyoshi Koizumi.
2012-03-17 18:24:07 +00:00
if (event_initialized(&tty->key_timer))
evtimer_del(&tty->key_timer);
Drop the no_stop argument to tty_close and tty_free in favour of a flag in the tty struct.
2009-08-11 19:32:25 +00:00
tty_stop_tty(tty);
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
Add a TTY_OPENED flag and tidy a little.
2009-08-11 20:29:04 +00:00
if (tty->flags & TTY_OPENED) {
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
evbuffer_free(tty->in);
event_del(&tty->event_in);
evbuffer_free(tty->out);
event_del(&tty->event_out);
Switch tty fds over to a bufferevent.
2009-11-04 21:47:42 +00:00
Add a TTY_OPENED flag and tidy a little.
2009-08-11 20:29:04 +00:00
tty_term_free(tty->term);
tty_keys_free(tty);
tty->flags &= ~TTY_OPENED;
}
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
}
void
Drop the no_stop argument to tty_close and tty_free in favour of a flag in the tty struct.
2009-08-11 19:32:25 +00:00
tty_free(struct tty *tty)
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
{
Drop the no_stop argument to tty_close and tty_free in favour of a flag in the tty struct.
2009-08-11 19:32:25 +00:00
tty_close(tty);
xfree is not particularly helpful, remove it. From Thomas Adam.
2012-07-10 11:53:01 +00:00
free(tty->ccolour);
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
}
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
void
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
tty_update_features(struct tty *tty)
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
{
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
struct client *c = tty->client;
Apply terminal-overrides after terminal detection, it always takes precedence.
2020-04-20 15:37:32 +00:00
if (tty_apply_features(tty->term, c->term_features))
tty_term_apply_overrides(tty->term);
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
if (tty_use_margin(tty))
Add extension terminfo(5) capabilities for margins.
2020-05-16 14:22:51 +00:00
tty_putcode(tty, TTYC_ENMG);
Add a terminal feature for enable/disable extended keys (supported by xterm and mintty) and add an option to make tmux send it. Only forward extended keys if the application has requested them, even though we use the CSI u sequence and xterm uses CSI 27 ~ - this is what mintty does as well.
2020-05-16 16:44:54 +00:00
if (options_get_number(global_options, "extended-keys"))
tty_puts(tty, tty_term_string(tty->term, TTYC_ENEKS));
if (options_get_number(global_options, "focus-events"))
xterm* can have focus too.
2020-05-22 15:08:38 +00:00
tty_puts(tty, tty_term_string(tty->term, TTYC_ENFCS));
Add a terminal feature for enable/disable extended keys (supported by xterm and mintty) and add an option to make tmux send it. Only forward extended keys if the application has requested them, even though we use the CSI u sequence and xterm uses CSI 27 ~ - this is what mintty does as well.
2020-05-16 16:44:54 +00:00
if (tty->term->flags & TERM_VT100LIKE)
tty_puts(tty, "\033[?7727h");
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +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
void
tty_raw(struct tty *tty, const char *s)
{
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
struct client *c = tty->client;
ssize_t n, slen;
u_int i;
Correctly handle UTF8 mouse option being toggled, from Egmont Koblinger.
2013-03-22 10:34:46 +00:00
slen = strlen(s);
for (i = 0; i < 5; i++) {
Now the tty has a pointer back to the client there is no point (and a bit confusing) in it keeping a copy of the fd as well. Remove it.
2020-05-24 09:13:06 +00:00
n = write(c->fd, s, slen);
Correctly handle UTF8 mouse option being toggled, from Egmont Koblinger.
2013-03-22 10:34:46 +00:00
if (n >= 0) {
s += n;
slen -= n;
if (slen == 0)
break;
} else if (n == -1 && errno != EAGAIN)
break;
usleep(100);
}
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
}
void
tty_putcode(struct tty *tty, enum tty_code_code code)
{
tty_puts(tty, tty_term_string(tty->term, code));
}
void
tty_putcode1(struct tty *tty, enum tty_code_code code, int a)
{
if (a < 0)
return;
tty_puts(tty, tty_term_string1(tty->term, code, a));
}
void
tty_putcode2(struct tty *tty, enum tty_code_code code, int a, int b)
{
if (a < 0 || b < 0)
return;
tty_puts(tty, tty_term_string2(tty->term, code, a, b));
}
Look for setrgbf and setrgbb terminfo extensions for RGB colour. This is the most reasonable of the various (some bizarre) suggestions for capabilities.
2017-05-31 08:43:44 +00:00
void
tty_putcode3(struct tty *tty, enum tty_code_code code, int a, int b, int c)
{
if (a < 0 || b < 0 || c < 0)
return;
tty_puts(tty, tty_term_string3(tty->term, code, a, b, c));
}
Support xterm(1) cursor colour change sequences through terminfo(5) Cc (set) and Cr (reset) extensions. Originally by Sean Estabrooks, tweaked by me and Ailin Nemui.
2011-05-20 19:03:58 +00:00
void
tty_putcode_ptr1(struct tty *tty, enum tty_code_code code, const void *a)
{
if (a != NULL)
tty_puts(tty, tty_term_ptr1(tty->term, code, a));
}
Support setting the xterm clipboard when copying from copy mode using the xterm escape sequence for the purpose (if xterm is configured to allow it). Written by and much discussed Ailin Nemui, guidance on xterm/termcap/terminfo from Thomas Dickey.
2011-05-18 20:24:29 +00:00
void
Wrap some long lines.
2014-04-17 12:57:28 +00:00
tty_putcode_ptr2(struct tty *tty, enum tty_code_code code, const void *a,
const void *b)
Support setting the xterm clipboard when copying from copy mode using the xterm escape sequence for the purpose (if xterm is configured to allow it). Written by and much discussed Ailin Nemui, guidance on xterm/termcap/terminfo from Thomas Dickey.
2011-05-18 20:24:29 +00:00
{
if (a != NULL && b != NULL)
tty_puts(tty, tty_term_ptr2(tty->term, code, a, b));
}
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
static void
tty_add(struct tty *tty, const char *buf, size_t len)
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
{
Give each client a name. This defaults to the tty name as before but falls back to an alternative if the tty name is not available. This is clearer than overloading the client ttyname member and allows us to remove the path stored in the tty struct, it should always be the same as the client.
2017-04-05 10:49:46 +00:00
struct client *c = tty->client;
When the data we have buffered to write to a terminal grows beyond a reasonable amount (currently width * height * 8 bytes), discard all output to the terminal and start trying to redraw periodically instead. Continue with this until the amount of data we are trying to write falls to a low level again. This helps to prevent tmux sitting on a huge buffer of data when there are processes with fast output running inside tmux but the outside terminal is slow. A new client_discarded format holds the amount of data that has been discarded due to this mechanism. The three variables (when to start this, when to stop, and how often to redraw) are basically "works for me" at the moment, this is going in to see how it goes and if it causes problems for anyone else.
2017-04-19 06:52:27 +00:00
if (tty->flags & TTY_BLOCK) {
tty->discarded += len;
return;
}
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
evbuffer_add(tty->out, buf, len);
If the current screen was complex enough, it was possible to make redraw itself hit the "terminal can't keep up" check. To avoid this, record how much data we send during redraw (we know we will be starting with 0) and skip the check until it has been flushed. GitHub issue 912.
2017-05-09 13:04:36 +00:00
log_debug("%s: %.*s", c->name, (int)len, buf);
When the data we have buffered to write to a terminal grows beyond a reasonable amount (currently width * height * 8 bytes), discard all output to the terminal and start trying to redraw periodically instead. Continue with this until the amount of data we are trying to write falls to a low level again. This helps to prevent tmux sitting on a huge buffer of data when there are processes with fast output running inside tmux but the outside terminal is slow. A new client_discarded format holds the amount of data that has been discarded due to this mechanism. The three variables (when to start this, when to stop, and how often to redraw) are basically "works for me" at the moment, this is going in to see how it goes and if it causes problems for anyone else.
2017-04-19 06:52:27 +00:00
c->written += len;
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
The output log is only useful once and it means creating a file, so open it once at startup instead of in every call to tty_open.
2015-10-31 13:12:03 +00:00
if (tty_log_fd != -1)
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
write(tty_log_fd, buf, len);
Don't use a bufferevent for the tty, so we can keep better track of what is being written and when. Also a manpage typo fix from jmc@.
2017-02-10 12:59:18 +00:00
if (tty->flags & TTY_STARTED)
event_add(&tty->event_out, NULL);
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
}
void
tty_puts(struct tty *tty, const char *s)
{
if (*s != '\0')
tty_add(tty, s, strlen(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
}
void
tty_putc(struct tty *tty, u_char ch)
{
Use UTF-8 line drawing characters on UTF-8 terminals. Fixes some stupid terminals (I'm looking at you, putty) which disable the vt100 ACS mode switching sequences in UTF-8 mode. Also on terminals without ACS at all, use ASCII equivalents where obvious.
2010-09-11 16:19:22 +00:00
const char *acs;
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 various confusion about am vs xenl.
2020-06-05 09:32:15 +00:00
if ((tty->term->flags & TERM_NOAM) &&
I had hoped that non-xenl terminals had died out, at least in fairly modern OSs, but no - DragonFly BSD's console returns to haunt us. Fix it at least somewhat. GitHub issue 1763.
2019-05-30 07:42:41 +00:00
ch >= 0x20 && ch != 0x7f &&
tty->cy == tty->sy - 1 &&
tty->cx + 1 >= tty->sx)
return;
Use UTF-8 line drawing characters on UTF-8 terminals. Fixes some stupid terminals (I'm looking at you, putty) which disable the vt100 ACS mode switching sequences in UTF-8 mode. Also on terminals without ACS at all, use ASCII equivalents where obvious.
2010-09-11 16:19:22 +00:00
if (tty->cell.attr & GRID_ATTR_CHARSET) {
acs = tty_acs_get(tty, ch);
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
if (acs != NULL)
tty_add(tty, acs, strlen(acs));
else
tty_add(tty, &ch, 1);
} else
tty_add(tty, &ch, 1);
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
if (ch >= 0x20 && ch != 0x7f) {
Don't make assumptions about line wrap on !xenl terminals, means that using a wrong TERM without xenl is not so broken if used on a sensible terminal.
2016-10-14 21:48:00 +00:00
if (tty->cx >= tty->sx) {
When drawing lines that have wrapped naturally, don't force a newline but permit them to wrap naturally again. This allows terminals that use this to guess where lines start and end for eg mouse selecting (like xterm) to work correctly. This was another long-standing issue raised by several people over the last while. Thanks to martynas@ for much testing. This was not trivial to get right so bringing it in for wider testing and adn to fix any further glitches in-tree.
2009-10-12 17:19:47 +00:00
tty->cx = 1;
if (tty->cy != tty->rlower)
tty->cy++;
Don't make assumptions about line wrap on !xenl terminals, means that using a wrong TERM without xenl is not so broken if used on a sensible terminal.
2016-10-14 21:48:00 +00:00
/*
Fix various confusion about am vs xenl.
2020-06-05 09:32:15 +00:00
* On !am terminals, force the cursor position to where
* we think it should be after a line wrap - this means
* it works on sensible terminals as well.
Don't make assumptions about line wrap on !xenl terminals, means that using a wrong TERM without xenl is not so broken if used on a sensible terminal.
2016-10-14 21:48:00 +00:00
*/
Fix various confusion about am vs xenl.
2020-06-05 09:32:15 +00:00
if (tty->term->flags & TERM_NOAM)
Don't make assumptions about line wrap on !xenl terminals, means that using a wrong TERM without xenl is not so broken if used on a sensible terminal.
2016-10-14 21:48:00 +00:00
tty_putcode2(tty, TTYC_CUP, tty->cy, tty->cx);
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
} else
tty->cx++;
}
}
Trying to predict the cursor position for UTF-8 output in the same way as for normal eight-bit output is wrong, separate it into a different function. Fixes spacing when mixing UTF-8 with some escape sequences, notably the way w3m does it.
2009-06-24 16:01:02 +00:00
void
Rather than having two grids for each pane, one for ASCII and one for UTF-8, collapse the two together. Simplifies the code at the expense of more memory (which can probably be reduced again later).
2013-01-18 02:16:21 +00:00
tty_putn(struct tty *tty, const void *buf, size_t len, u_int width)
Trying to predict the cursor position for UTF-8 output in the same way as for normal eight-bit output is wrong, separate it into a different function. Fixes spacing when mixing UTF-8 with some escape sequences, notably the way w3m does it.
2009-06-24 16:01:02 +00:00
{
Fix various confusion about am vs xenl.
2020-06-05 09:32:15 +00:00
if ((tty->term->flags & TERM_NOAM) &&
I had hoped that non-xenl terminals had died out, at least in fairly modern OSs, but no - DragonFly BSD's console returns to haunt us. Fix it at least somewhat. GitHub issue 1763.
2019-05-30 07:42:41 +00:00
tty->cy == tty->sy - 1 &&
tty->cx + len >= tty->sx)
len = tty->sx - tty->cx - 1;
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
tty_add(tty, buf, len);
Make full width panes try to play more nicely with terminal copy and paste by avoiding explicit line wraps if we think the terminal will wrap anyway.
2017-04-25 18:30:29 +00:00
if (tty->cx + width > tty->sx) {
tty->cx = (tty->cx + width) - tty->sx;
if (tty->cx <= tty->sx)
tty->cy++;
else
tty->cx = tty->cy = UINT_MAX;
} else
Invalidate the cursor when we think we should have wrapped.
2017-03-15 15:22:14 +00:00
tty->cx += width;
Trying to predict the cursor position for UTF-8 output in the same way as for normal eight-bit output is wrong, separate it into a different function. Fixes spacing when mixing UTF-8 with some escape sequences, notably the way w3m does it.
2009-06-24 16:01:02 +00:00
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
If default-terminal is set to "screen" or "screen-*", emulate screen's historical (incorrect) behaviour for SGR 3 and send smso (standout). Previously, we would send sitm (italics) if the terminal outside had it and smso otherwise. This was acceptably until recently because xterm's terminfo entry lacked sitm, so most users got smso. People who want italics should set default-terminal to the forthcoming "tmux" entry (and be prepared to deal with it being missing on older hosts). As a side-effect this changes default-terminal to be a server rather than a session option. suggested by and ok naddy
2015-04-29 15:59:08 +00:00
tty_set_italics(struct tty *tty)
{
const char *s;
if (tty_term_has(tty->term, TTYC_SITM)) {
Move struct options into options.c.
2015-10-27 15:58:42 +00:00
s = options_get_string(global_options, "default-terminal");
If default-terminal is set to "screen" or "screen-*", emulate screen's historical (incorrect) behaviour for SGR 3 and send smso (standout). Previously, we would send sitm (italics) if the terminal outside had it and smso otherwise. This was acceptably until recently because xterm's terminfo entry lacked sitm, so most users got smso. People who want italics should set default-terminal to the forthcoming "tmux" entry (and be prepared to deal with it being missing on older hosts). As a side-effect this changes default-terminal to be a server rather than a session option. suggested by and ok naddy
2015-04-29 15:59:08 +00:00
if (strcmp(s, "screen") != 0 && strncmp(s, "screen-", 7) != 0) {
tty_putcode(tty, TTYC_SITM);
return;
}
}
tty_putcode(tty, TTYC_SMSO);
}
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
void
tty_set_title(struct tty *tty, const char *title)
{
Use the tsl and fsl terminfo(5) capabilities to update terminal title and automatically fill them in on terminals with the XT capability (which means their title setting is xterm-compatible). From hsim at gmx.li.
2011-05-08 19:53:06 +00:00
if (!tty_term_has(tty->term, TTYC_TSL) ||
!tty_term_has(tty->term, TTYC_FSL))
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
return;
Use the tsl and fsl terminfo(5) capabilities to update terminal title and automatically fill them in on terminals with the XT capability (which means their title setting is xterm-compatible). From hsim at gmx.li.
2011-05-08 19:53:06 +00:00
tty_putcode(tty, TTYC_TSL);
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
tty_puts(tty, title);
Use the tsl and fsl terminfo(5) capabilities to update terminal title and automatically fill them in on terminals with the XT capability (which means their title setting is xterm-compatible). From hsim at gmx.li.
2011-05-08 19:53:06 +00:00
tty_putcode(tty, TTYC_FSL);
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
}
Add static in window-*.c and move some internal functions out of tmux.h.
2016-10-11 13:21:59 +00:00
static void
Support xterm(1) cursor colour change sequences through terminfo(5) Cc (set) and Cr (reset) extensions. Originally by Sean Estabrooks, tweaked by me and Ailin Nemui.
2011-05-20 19:03:58 +00:00
tty_force_cursor_colour(struct tty *tty, const char *ccolour)
{
if (*ccolour == '\0')
tty_putcode(tty, TTYC_CR);
else
The actual terminfo entries we ended up with for cursor changes are Cs, Ce, Ss and Se (not Cc, Ce, Cs, Csr). So use and document these instead of the ones we were using earlier.
2013-06-02 07:52:15 +00:00
tty_putcode_ptr1(tty, TTYC_CS, ccolour);
xfree is not particularly helpful, remove it. From Thomas Adam.
2012-07-10 11:53:01 +00:00
free(tty->ccolour);
Support xterm(1) cursor colour change sequences through terminfo(5) Cc (set) and Cr (reset) extensions. Originally by Sean Estabrooks, tweaked by me and Ailin Nemui.
2011-05-20 19:03:58 +00:00
tty->ccolour = xstrdup(ccolour);
}
void
tty_update_mode(struct tty *tty, int mode, struct screen *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
{
VTE treats each mouse mode bit as independent, so turning off 1000 doesn't also turn off 1001, so don't rely on that behaviour. GitHub issue 2116.
2020-03-16 10:49:06 +00:00
struct client *c = tty->client;
int changed;
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
Couple of trivial style nits.
2015-12-28 14:02:52 +00:00
if (s != NULL && strcmp(s->ccolour, tty->ccolour) != 0)
Support xterm(1) cursor colour change sequences through terminfo(5) Cc (set) and Cr (reset) extensions. Originally by Sean Estabrooks, tweaked by me and Ailin Nemui.
2011-05-20 19:03:58 +00:00
tty_force_cursor_colour(tty, s->ccolour);
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
if (tty->flags & TTY_NOCURSOR)
mode &= ~MODE_CURSOR;
changed = mode ^ tty->mode;
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
if (changed != 0)
log_debug("%s: update mode %x to %x", c->name, tty->mode, mode);
VTE treats each mouse mode bit as independent, so turning off 1000 doesn't also turn off 1001, so don't rely on that behaviour. GitHub issue 2116.
2020-03-16 10:49:06 +00:00
In terminfo, sometimes cvvis implies cnorm and sometimes it doesn't, so don't assume it does. Fixes missing cursor with emacs-in-tmux-in-tmux.
2015-05-19 08:48:37 +00:00
if (changed & MODE_BLINKING) {
if (tty_term_has(tty->term, TTYC_CVVIS))
tty_putcode(tty, TTYC_CVVIS);
else
tty_putcode(tty, TTYC_CNORM);
changed |= MODE_CURSOR;
}
if (changed & MODE_CURSOR) {
if (mode & MODE_CURSOR)
tty_putcode(tty, TTYC_CNORM);
else
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
tty_putcode(tty, TTYC_CIVIS);
}
Turn cursor off during redraw, pointed out by George Nachman.
2015-05-06 07:52:06 +00:00
if (s != NULL && tty->cstyle != s->cstyle) {
The actual terminfo entries we ended up with for cursor changes are Cs, Ce, Ss and Se (not Cc, Ce, Cs, Csr). So use and document these instead of the ones we were using earlier.
2013-06-02 07:52:15 +00:00
if (tty_term_has(tty->term, TTYC_SS)) {
Add a client flag 'active-pane' which stores the active pane in the client and allows it to be changed independently from the real active pane stored in the window. This is can be used with session groups which allow an independent current window (although it would be nice to have a flag for this too and remove session groups). The client active pane is only really useful interactively, many things (hooks, window-style, zooming) still use the window active pane.
2020-05-16 16:20:59 +00:00
if (s->cstyle == 0 && tty_term_has(tty->term, TTYC_SE))
The actual terminfo entries we ended up with for cursor changes are Cs, Ce, Ss and Se (not Cc, Ce, Cs, Csr). So use and document these instead of the ones we were using earlier.
2013-06-02 07:52:15 +00:00
tty_putcode(tty, TTYC_SE);
Support DECSCUSR sequence to set the cursor style with two new terminfo(5) extensions, Cs and Csr. Written by Ailin Nemui.
2011-05-20 19:17:39 +00:00
else
The actual terminfo entries we ended up with for cursor changes are Cs, Ce, Ss and Se (not Cc, Ce, Cs, Csr). So use and document these instead of the ones we were using earlier.
2013-06-02 07:52:15 +00:00
tty_putcode1(tty, TTYC_SS, s->cstyle);
Support DECSCUSR sequence to set the cursor style with two new terminfo(5) extensions, Cs and Csr. Written by Ailin Nemui.
2011-05-20 19:17:39 +00:00
}
tty->cstyle = s->cstyle;
}
VTE treats each mouse mode bit as independent, so turning off 1000 doesn't also turn off 1001, so don't rely on that behaviour. GitHub issue 2116.
2020-03-16 10:49:06 +00:00
if ((changed & ALL_MOUSE_MODES) &&
tty_term_has(tty->term, TTYC_KMOUS)) {
If mouse bits change, clear them all and set again to avoid problems with some bits implying others. GitHub issue 2458.
2020-11-09 10:54:28 +00:00
/*
* If the mouse modes have changed, clear any that are set and
* apply again. There are differences in how terminals track
* the various bits.
*/
if (tty->mode & MODE_MOUSE_SGR)
Correctly handle UTF8 mouse option being toggled, from Egmont Koblinger.
2013-03-22 10:34:46 +00:00
tty_puts(tty, "\033[?1006l");
If mouse bits change, clear them all and set again to avoid problems with some bits implying others. GitHub issue 2458.
2020-11-09 10:54:28 +00:00
if (tty->mode & MODE_MOUSE_STANDARD)
VTE treats each mouse mode bit as independent, so turning off 1000 doesn't also turn off 1001, so don't rely on that behaviour. GitHub issue 2116.
2020-03-16 10:49:06 +00:00
tty_puts(tty, "\033[?1000l");
If mouse bits change, clear them all and set again to avoid problems with some bits implying others. GitHub issue 2458.
2020-11-09 10:54:28 +00:00
if (tty->mode & MODE_MOUSE_BUTTON)
VTE treats each mouse mode bit as independent, so turning off 1000 doesn't also turn off 1001, so don't rely on that behaviour. GitHub issue 2116.
2020-03-16 10:49:06 +00:00
tty_puts(tty, "\033[?1002l");
If mouse bits change, clear them all and set again to avoid problems with some bits implying others. GitHub issue 2458.
2020-11-09 10:54:28 +00:00
if (tty->mode & MODE_MOUSE_ALL)
VTE treats each mouse mode bit as independent, so turning off 1000 doesn't also turn off 1001, so don't rely on that behaviour. GitHub issue 2116.
2020-03-16 10:49:06 +00:00
tty_puts(tty, "\033[?1003l");
if (mode & ALL_MOUSE_MODES)
tty_puts(tty, "\033[?1006h");
If mouse bits change, clear them all and set again to avoid problems with some bits implying others. GitHub issue 2458.
2020-11-09 10:54:28 +00:00
if (mode & MODE_MOUSE_STANDARD)
VTE treats each mouse mode bit as independent, so turning off 1000 doesn't also turn off 1001, so don't rely on that behaviour. GitHub issue 2116.
2020-03-16 10:49:06 +00:00
tty_puts(tty, "\033[?1000h");
If mouse bits change, clear them all and set again to avoid problems with some bits implying others. GitHub issue 2458.
2020-11-09 10:54:28 +00:00
if (mode & MODE_MOUSE_BUTTON)
VTE treats each mouse mode bit as independent, so turning off 1000 doesn't also turn off 1001, so don't rely on that behaviour. GitHub issue 2116.
2020-03-16 10:49:06 +00:00
tty_puts(tty, "\033[?1002h");
If mouse bits change, clear them all and set again to avoid problems with some bits implying others. GitHub issue 2458.
2020-11-09 10:54:28 +00:00
if (mode & MODE_MOUSE_ALL)
VTE treats each mouse mode bit as independent, so turning off 1000 doesn't also turn off 1001, so don't rely on that behaviour. GitHub issue 2116.
2020-03-16 10:49:06 +00:00
tty_puts(tty, "\033[?1003h");
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 "bracketed paste" mode. This adds a -p flag to paste-buffer - if this is used and the application has requested bracketed pastes, then tmux surrounds the pasted text by \033[200~ and \033[201~. Applications like vim can (apparently) use this to avoid, for example, indenting the text. From Ailin Nemui.
2012-03-03 09:43:22 +00:00
if (changed & MODE_BRACKETPASTE) {
if (mode & MODE_BRACKETPASTE)
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
tty_putcode(tty, TTYC_ENBP);
Support "bracketed paste" mode. This adds a -p flag to paste-buffer - if this is used and the application has requested bracketed pastes, then tmux surrounds the pasted text by \033[200~ and \033[201~. Applications like vim can (apparently) use this to avoid, for example, indenting the text. From Ailin Nemui.
2012-03-03 09:43:22 +00:00
else
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
tty_putcode(tty, TTYC_DSBP);
Support "bracketed paste" mode. This adds a -p flag to paste-buffer - if this is used and the application has requested bracketed pastes, then tmux surrounds the pasted text by \033[200~ and \033[201~. Applications like vim can (apparently) use this to avoid, for example, indenting the text. From Ailin Nemui.
2012-03-03 09:43:22 +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
tty->mode = mode;
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Some more long lines.
2014-04-17 14:45:49 +00:00
tty_emulate_repeat(struct tty *tty, enum tty_code_code code,
enum tty_code_code code1, u_int n)
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
{
if (tty_term_has(tty->term, code))
tty_putcode1(tty, code, n);
else {
while (n-- > 0)
tty_putcode(tty, code1);
}
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Move some common code to repeat spaces into a function.
2012-05-22 09:09:16 +00:00
tty_repeat_space(struct tty *tty, u_int n)
{
Give each client a name. This defaults to the tty name as before but falls back to an alternative if the tty name is not available. This is clearer than overloading the client ttyname member and allows us to remove the path stored in the tty struct, it should always be the same as the client.
2017-04-05 10:49:46 +00:00
static char s[500];
if (*s != ' ')
memset(s, ' ', sizeof s);
while (n > sizeof s) {
tty_putn(tty, s, sizeof s, sizeof s);
n -= sizeof s;
}
if (n != 0)
tty_putn(tty, s, n, n);
Move some common code to repeat spaces into a function.
2012-05-22 09:09:16 +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
/* Is this window bigger than the terminal? */
int
tty_window_bigger(struct tty *tty)
Some tidying and helper functions.
2018-08-18 16:14:03 +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
struct client *c = tty->client;
struct window *w = c->session->curw->window;
Some tidying and helper functions.
2018-08-18 16:14:03 +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
return (tty->sx < w->sx || tty->sy - status_line_size(c) < w->sy);
}
/* What offset should this window be drawn at? */
int
tty_window_offset(struct tty *tty, u_int *ox, u_int *oy, u_int *sx, u_int *sy)
{
*ox = tty->oox;
*oy = tty->ooy;
*sx = tty->osx;
*sy = tty->osy;
return (tty->oflag);
}
/* What offset should this window be drawn at? */
static int
tty_window_offset1(struct tty *tty, u_int *ox, u_int *oy, u_int *sx, u_int *sy)
{
struct client *c = tty->client;
struct window *w = c->session->curw->window;
Add a client flag 'active-pane' which stores the active pane in the client and allows it to be changed independently from the real active pane stored in the window. This is can be used with session groups which allow an independent current window (although it would be nice to have a flag for this too and remove session groups). The client active pane is only really useful interactively, many things (hooks, window-style, zooming) still use the window active pane.
2020-05-16 16:20:59 +00:00
struct window_pane *wp = server_client_get_pane(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
u_int cx, cy, lines;
lines = status_line_size(c);
if (tty->sx >= w->sx && tty->sy - lines >= w->sy) {
*ox = 0;
*oy = 0;
*sx = w->sx;
*sy = w->sy;
c->pan_window = NULL;
return (0);
}
*sx = tty->sx;
*sy = tty->sy - lines;
if (c->pan_window == w) {
if (*sx >= w->sx)
c->pan_ox = 0;
else if (c->pan_ox + *sx > w->sx)
c->pan_ox = w->sx - *sx;
*ox = c->pan_ox;
if (*sy >= w->sy)
c->pan_oy = 0;
else if (c->pan_oy + *sy > w->sy)
c->pan_oy = w->sy - *sy;
*oy = c->pan_oy;
return (1);
}
if (~wp->screen->mode & MODE_CURSOR) {
*ox = 0;
*oy = 0;
} else {
cx = wp->xoff + wp->screen->cx;
cy = wp->yoff + wp->screen->cy;
if (cx < *sx)
*ox = 0;
else if (cx > w->sx - *sx)
*ox = w->sx - *sx;
else
*ox = cx - *sx / 2;
if (cy < *sy)
*oy = 0;
else if (cy > w->sy - *sy)
*oy = w->sy - *sy;
else
*oy = cy - *sy / 2;
}
c->pan_window = NULL;
return (1);
}
/* Update stored offsets for a window and redraw if necessary. */
void
tty_update_window_offset(struct window *w)
{
struct client *c;
TAILQ_FOREACH(c, &clients, entry) {
if (c->session != NULL && c->session->curw->window == w)
tty_update_client_offset(c);
}
}
/* Update stored offsets for a client and redraw if necessary. */
void
tty_update_client_offset(struct client *c)
{
u_int ox, oy, sx, sy;
Don't set client offset if client is not a terminal
2019-03-04 09:29:40 +00:00
if (~c->flags & CLIENT_TERMINAL)
return;
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->tty.oflag = tty_window_offset1(&c->tty, &ox, &oy, &sx, &sy);
if (ox == c->tty.oox &&
oy == c->tty.ooy &&
sx == c->tty.osx &&
sy == c->tty.osy)
return;
log_debug ("%s: %s offset has changed (%u,%u %ux%u -> %u,%u %ux%u)",
__func__, c->name, c->tty.oox, c->tty.ooy, c->tty.osx, c->tty.osy,
ox, oy, sx, sy);
c->tty.oox = ox;
c->tty.ooy = oy;
c->tty.osx = sx;
c->tty.osy = sy;
c->flags |= (CLIENT_REDRAWWINDOW|CLIENT_REDRAWSTATUS);
Some tidying and helper functions.
2018-08-18 16:14:03 +00:00
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
/* Get a palette entry. */
static int
tty_get_palette(int *palette, int c)
{
int new;
if (palette == NULL)
return (-1);
new = -1;
if (c < 8)
new = palette[c];
else if (c >= 90 && c <= 97)
new = palette[8 + c - 90];
else if (c & COLOUR_FLAG_256)
new = palette[c & ~COLOUR_FLAG_256];
if (new == 0)
return (-1);
return (new);
}
Add a helper function for enabling an optimization to make some code clearer.
2012-03-15 09:10:33 +00:00
/*
* Is the region large enough to be worth redrawing once later rather than
* probably several times now? Currently yes if it is more than 50% of the
* pane.
*/
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int
Use __unused rather than rolling our own.
2015-11-18 14:27:44 +00:00
tty_large_region(__unused struct tty *tty, const struct tty_ctx *ctx)
Add a helper function for enabling an optimization to make some code clearer.
2012-03-15 09:10:33 +00:00
{
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
return (ctx->orlower - ctx->orupper >= ctx->sy / 2);
Add a helper function for enabling an optimization to make some code clearer.
2012-03-15 09:10:33 +00:00
}
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +00:00
/*
* Return if BCE is needed but the terminal doesn't have it - it'll need to be
* emulated.
*/
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_fake_bce(const struct tty *tty, const struct grid_cell *gc, u_int bg)
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +00:00
{
Add support for BCE (background colour erase). This makes various escape sequences (notable EL and ED but also IL, DL, ICH, DCH) create blank cells using the current background colour rather than the default colour. On modern systems BCE doesn't really have many benefits, but most other terminals now support it, some (lazy) applications rely on it, and it is not hard to include now that we have pane background colours anyway. Mostly written by Sean Haugh.
2016-10-13 20:27:27 +00:00
if (tty_term_flag(tty->term, TTYC_BCE))
return (0);
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if (!COLOUR_DEFAULT(bg) || !COLOUR_DEFAULT(gc->bg))
Add support for BCE (background colour erase). This makes various escape sequences (notable EL and ED but also IL, DL, ICH, DCH) create blank cells using the current background colour rather than the default colour. On modern systems BCE doesn't really have many benefits, but most other terminals now support it, some (lazy) applications rely on it, and it is not hard to include now that we have pane background colours anyway. Mostly written by Sean Haugh.
2016-10-13 20:27:27 +00:00
return (1);
return (0);
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +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
/*
* Redraw scroll region using data from screen (already updated). Used when
* CSR not supported, or window is a pane that doesn't take up the full
* width of the terminal.
*/
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_redraw_region(struct tty *tty, const struct tty_ctx *ctx)
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
{
Bring back previons fix to only redraw panes that need it after a redraw is deferred, but clear the pane flags when they are actually redrawn rather than every time.
2020-04-18 07:32:53 +00:00
struct client *c = tty->client;
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
u_int i;
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
* If region is large, schedule a redraw. In most cases this is likely
* to be followed by some more scrolling.
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
*/
Add a helper function for enabling an optimization to make some code clearer.
2012-03-15 09:10:33 +00:00
if (tty_large_region(tty, ctx)) {
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
log_debug("%s: %s large redraw", __func__, c->name);
ctx->redraw_cb(ctx);
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
return;
}
More tty code tidying: move the saved cursor/region position (from before the screen was updated) out of struct screen and into struct tty_ctx.
2009-07-22 20:53:38 +00:00
if (ctx->ocy < ctx->orupper || ctx->ocy > ctx->orlower) {
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
for (i = ctx->ocy; i < ctx->sy; i++)
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
tty_draw_pane(tty, ctx, i);
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
} else {
More tty code tidying: move the saved cursor/region position (from before the screen was updated) out of struct screen and into struct tty_ctx.
2009-07-22 20:53:38 +00:00
for (i = ctx->orupper; i <= ctx->orlower; i++)
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
tty_draw_pane(tty, ctx, i);
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
/* Is this position visible in the pane? */
static int
Do not need to work out status line offset, we already have it.
2020-05-16 15:36:57 +00:00
tty_is_visible(__unused struct tty *tty, const struct tty_ctx *ctx, u_int px,
u_int py, u_int nx, u_int ny)
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
{
Do not need to work out status line offset, we already have it.
2020-05-16 15:36:57 +00:00
u_int xoff = ctx->rxoff + px, yoff = ctx->ryoff + py;
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 (!ctx->bigger)
return (1);
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
if (xoff + nx <= ctx->wox || xoff >= ctx->wox + ctx->wsx ||
Do not need to work out status line offset, we already have it.
2020-05-16 15:36:57 +00:00
yoff + ny <= ctx->woy || yoff >= ctx->woy + ctx->wsy)
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
return (0);
return (1);
}
/* Clamp line position to visible part of pane. */
static int
tty_clamp_line(struct tty *tty, const struct tty_ctx *ctx, u_int px, u_int py,
u_int nx, u_int *i, u_int *x, u_int *rx, u_int *ry)
{
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
u_int xoff = ctx->rxoff + px;
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 (!tty_is_visible(tty, ctx, px, py, nx, 1))
return (0);
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*ry = ctx->yoff + py - ctx->woy;
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
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
if (xoff >= ctx->wox && xoff + nx <= ctx->wox + ctx->wsx) {
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
/* All visible. */
*i = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*x = ctx->xoff + px - ctx->wox;
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
*rx = nx;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
} else if (xoff < ctx->wox && xoff + nx > ctx->wox + ctx->wsx) {
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
/* Both left and right not visible. */
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*i = ctx->wox;
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
*x = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*rx = ctx->wsx;
} else if (xoff < ctx->wox) {
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
/* Left not visible. */
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*i = ctx->wox - (ctx->xoff + px);
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
*x = 0;
*rx = nx - *i;
} else {
/* Right not visible. */
*i = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*x = (ctx->xoff + px) - ctx->wox;
*rx = ctx->wsx - *x;
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 (*rx > nx)
fatalx("%s: x too big, %u > %u", __func__, *rx, nx);
return (1);
}
/* Clear a line. */
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +00:00
static void
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_clear_line(struct tty *tty, const struct grid_cell *defaults, u_int py,
u_int px, u_int nx, u_int bg)
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
struct client *c = tty->client;
log_debug("%s: %s, %u at %u,%u", __func__, c->name, nx, px, py);
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +00:00
/* Nothing to clear. */
if (nx == 0)
return;
/* If genuine BCE is available, can try escape sequences. */
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if (!tty_fake_bce(tty, defaults, bg)) {
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +00:00
/* Off the end of the line, use EL if available. */
if (px + nx >= tty->sx && tty_term_has(tty->term, TTYC_EL)) {
tty_cursor(tty, px, py);
tty_putcode(tty, TTYC_EL);
return;
}
/* At the start of the line. Use EL1. */
if (px == 0 && tty_term_has(tty->term, TTYC_EL1)) {
tty_cursor(tty, px + nx - 1, py);
tty_putcode(tty, TTYC_EL1);
return;
}
/* Section of line. Use ECH if possible. */
if (tty_term_has(tty->term, TTYC_ECH)) {
tty_cursor(tty, px, py);
tty_putcode1(tty, TTYC_ECH, nx);
return;
}
}
/* Couldn't use an escape sequence, use spaces. */
Move to the right cursor position before using spaces to clear.
2017-05-10 18:40:13 +00:00
tty_cursor(tty, px, py);
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +00:00
tty_repeat_space(tty, nx);
}
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 a line, adjusting to visible part of pane. */
static void
tty_clear_pane_line(struct tty *tty, const struct tty_ctx *ctx, u_int py,
u_int px, u_int nx, u_int bg)
{
struct client *c = tty->client;
u_int i, x, rx, ry;
log_debug("%s: %s, %u at %u,%u", __func__, c->name, nx, px, py);
if (tty_clamp_line(tty, ctx, px, py, nx, &i, &x, &rx, &ry))
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_clear_line(tty, &ctx->defaults, ry, x, rx, bg);
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
}
/* Clamp area position to visible part of pane. */
static int
tty_clamp_area(struct tty *tty, const struct tty_ctx *ctx, u_int px, u_int py,
u_int nx, u_int ny, u_int *i, u_int *j, u_int *x, u_int *y, u_int *rx,
u_int *ry)
{
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
u_int xoff = ctx->rxoff + px, yoff = ctx->ryoff + py;
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 (!tty_is_visible(tty, ctx, px, py, nx, ny))
return (0);
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
if (xoff >= ctx->wox && xoff + nx <= ctx->wox + ctx->wsx) {
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
/* All visible. */
*i = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*x = ctx->xoff + px - ctx->wox;
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
*rx = nx;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
} else if (xoff < ctx->wox && xoff + nx > ctx->wox + ctx->wsx) {
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
/* Both left and right not visible. */
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*i = ctx->wox;
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
*x = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*rx = ctx->wsx;
} else if (xoff < ctx->wox) {
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
/* Left not visible. */
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*i = ctx->wox - (ctx->xoff + px);
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
*x = 0;
*rx = nx - *i;
} else {
/* Right not visible. */
*i = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*x = (ctx->xoff + px) - ctx->wox;
*rx = ctx->wsx - *x;
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 (*rx > nx)
fatalx("%s: x too big, %u > %u", __func__, *rx, nx);
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
if (yoff >= ctx->woy && yoff + ny <= ctx->woy + ctx->wsy) {
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
/* All visible. */
*j = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*y = ctx->yoff + py - ctx->woy;
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
*ry = ny;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
} else if (yoff < ctx->woy && yoff + ny > ctx->woy + ctx->wsy) {
Fix some comments (top/bottom not left/right).
2019-06-26 13:05:06 +00:00
/* Both top and bottom not visible. */
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*j = ctx->woy;
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
*y = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*ry = ctx->wsy;
} else if (yoff < ctx->woy) {
Fix some comments (top/bottom not left/right).
2019-06-26 13:05:06 +00:00
/* Top not visible. */
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*j = ctx->woy - (ctx->yoff + py);
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
*y = 0;
*ry = ny - *j;
} else {
Fix some comments (top/bottom not left/right).
2019-06-26 13:05:06 +00:00
/* Bottom not visible. */
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
*j = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
*y = (ctx->yoff + py) - ctx->woy;
*ry = ctx->wsy - *y;
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 (*ry > ny)
fatalx("%s: y too big, %u > %u", __func__, *ry, ny);
return (1);
}
/* Clear an area, adjusting to visible part of pane. */
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +00:00
static void
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_clear_area(struct tty *tty, const struct grid_cell *defaults, u_int py,
u_int ny, u_int px, u_int nx, u_int bg)
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
struct client *c = tty->client;
u_int yy;
char tmp[64];
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
log_debug("%s: %s, %u,%u at %u,%u", __func__, c->name, nx, ny, px, py);
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +00:00
/* Nothing to clear. */
if (nx == 0 || ny == 0)
return;
/* If genuine BCE is available, can try escape sequences. */
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if (!tty_fake_bce(tty, defaults, bg)) {
Can use INDN to clear regions with default background colour if margins are supported.
2017-05-12 11:13:43 +00:00
/* Use ED if clearing off the bottom of the terminal. */
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +00:00
if (px == 0 &&
px + nx >= tty->sx &&
py + ny >= tty->sy &&
tty_term_has(tty->term, TTYC_ED)) {
tty_cursor(tty, 0, py);
tty_putcode(tty, TTYC_ED);
return;
}
ECH needs to use background colour.
2017-05-12 10:50:11 +00:00
/*
Can use INDN to clear regions with default background colour if margins are supported.
2017-05-12 11:13:43 +00:00
* On VT420 compatible terminals we can use DECFRA if the
* background colour isn't default (because it doesn't work
* after SGR 0).
ECH needs to use background colour.
2017-05-12 10:50:11 +00:00
*/
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
if ((tty->term->flags & TERM_DECFRA) && !COLOUR_DEFAULT(bg)) {
ECH needs to use background colour.
2017-05-12 10:50:11 +00:00
xsnprintf(tmp, sizeof tmp, "\033[32;%u;%u;%u;%u$x",
py + 1, px + 1, py + ny, px + nx);
tty_puts(tty, tmp);
return;
}
Can use INDN to clear regions with default background colour if margins are supported.
2017-05-12 11:13:43 +00:00
Can scroll away full lines to clear them too.
2017-05-12 23:06:43 +00:00
/* Full lines can be scrolled away to clear them. */
if (px == 0 &&
Compare >= for columns not >.
2017-05-12 23:10:19 +00:00
px + nx >= tty->sx &&
Can scroll away full lines to clear them too.
2017-05-12 23:06:43 +00:00
ny > 2 &&
tty_term_has(tty->term, TTYC_CSR) &&
tty_term_has(tty->term, TTYC_INDN)) {
tty_region(tty, py, py + ny - 1);
tty_margin_off(tty);
The Konsole SU bug means it can't clear the entire scroll region (it ignores if >= size, not if > as I first thought). So we can't effectively fix it in code - remove the workarounds which just cause bugs on other terminals.
2017-05-15 07:54:44 +00:00
tty_putcode1(tty, TTYC_INDN, ny);
Can scroll away full lines to clear them too.
2017-05-12 23:06:43 +00:00
return;
}
Can use INDN to clear regions with default background colour if margins are supported.
2017-05-12 11:13:43 +00:00
/*
* If margins are supported, can just scroll the area off to
* clear it.
*/
Regions can't be smaller than 2 so don't try to clear them by scrolling if so.
2017-05-12 11:19:24 +00:00
if (nx > 2 &&
ny > 2 &&
Can scroll away full lines to clear them too.
2017-05-12 23:06:43 +00:00
tty_term_has(tty->term, TTYC_CSR) &&
Regions can't be smaller than 2 so don't try to clear them by scrolling if so.
2017-05-12 11:19:24 +00:00
tty_use_margin(tty) &&
tty_term_has(tty->term, TTYC_INDN)) {
Can use INDN to clear regions with default background colour if margins are supported.
2017-05-12 11:13:43 +00:00
tty_region(tty, py, py + ny - 1);
tty_margin(tty, px, px + nx - 1);
The Konsole SU bug means it can't clear the entire scroll region (it ignores if >= size, not if > as I first thought). So we can't effectively fix it in code - remove the workarounds which just cause bugs on other terminals.
2017-05-15 07:54:44 +00:00
tty_putcode1(tty, TTYC_INDN, ny);
Can use INDN to clear regions with default background colour if margins are supported.
2017-05-12 11:13:43 +00:00
return;
}
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +00:00
}
/* Couldn't use an escape sequence, loop over the lines. */
for (yy = py; yy < py + ny; yy++)
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_clear_line(tty, defaults, yy, px, nx, bg);
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
/* Clear an area in a pane. */
static void
tty_clear_pane_area(struct tty *tty, const struct tty_ctx *ctx, u_int py,
u_int ny, u_int px, u_int nx, u_int bg)
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +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
u_int i, j, x, y, rx, ry;
if (tty_clamp_area(tty, ctx, px, py, nx, ny, &i, &j, &x, &y, &rx, &ry))
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_clear_area(tty, &ctx->defaults, y, ry, x, rx, bg);
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
}
static void
tty_draw_pane(struct tty *tty, const struct tty_ctx *ctx, u_int py)
{
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
struct screen *s = ctx->s;
u_int nx = ctx->sx, i, x, rx, ry;
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
log_debug("%s: %s %u %d", __func__, tty->client->name, py, ctx->bigger);
if (!ctx->bigger) {
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_draw_line(tty, s, 0, py, nx, ctx->xoff, ctx->yoff + py,
&ctx->defaults, ctx->palette);
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
return;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if (tty_clamp_line(tty, ctx, 0, py, nx, &i, &x, &rx, &ry)) {
tty_draw_line(tty, s, i, py, rx, x, ry, &ctx->defaults,
ctx->palette);
}
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +00:00
}
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
static const struct grid_cell *
tty_check_codeset(struct tty *tty, const struct grid_cell *gc)
{
static struct grid_cell new;
Add an option to set the pane border lines style from a choice of single lines (ACS or UTF-8), double or heavy (UTF-8), simple (plain ASCII) or number (the pane numbers). Lines that won't work on a non-UTF-8 terminal are translated back into ACS when they are output.
2020-05-16 16:26:34 +00:00
int c;
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
/* Characters less than 0x7f are always fine, no matter what. */
if (gc->data.size == 1 && *gc->data.data < 0x7f)
return (gc);
/* UTF-8 terminal and a UTF-8 character - fine. */
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
if (tty->client->flags & CLIENT_UTF8)
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
return (gc);
Add an option to set the pane border lines style from a choice of single lines (ACS or UTF-8), double or heavy (UTF-8), simple (plain ASCII) or number (the pane numbers). Lines that won't work on a non-UTF-8 terminal are translated back into ACS when they are output.
2020-05-16 16:26:34 +00:00
memcpy(&new, gc, sizeof new);
/* See if this can be mapped to an ACS character. */
c = tty_acs_reverse_get(tty, gc->data.data, gc->data.size);
if (c != -1) {
utf8_set(&new.data, c);
new.attr |= GRID_ATTR_CHARSET;
return (&new);
}
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
/* Replace by the right number of underscores. */
Add an option to set the pane border lines style from a choice of single lines (ACS or UTF-8), double or heavy (UTF-8), simple (plain ASCII) or number (the pane numbers). Lines that won't work on a non-UTF-8 terminal are translated back into ACS when they are output.
2020-05-16 16:26:34 +00:00
new.data.size = gc->data.width;
if (new.data.size > UTF8_SIZE)
new.data.size = UTF8_SIZE;
memset(new.data.data, '_', new.data.size);
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
return (&new);
}
Add support for overlay popup boxes to show text or output temporarily above the normal layout. These work similarly to menus and are created with the display-popup command.
2020-03-24 08:09:43 +00:00
static int
tty_check_overlay(struct tty *tty, u_int px, u_int py)
{
struct client *c = tty->client;
if (c->overlay_check == NULL)
return (1);
return (c->overlay_check(c, px, py));
}
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +00:00
void
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_draw_line(struct tty *tty, struct screen *s, u_int px, u_int py, u_int nx,
u_int atx, u_int aty, const struct grid_cell *defaults, int *palette)
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
{
If there is a double width character at the very end of the line with not enough room to draw it, just leave it out.
2017-11-15 19:18:57 +00:00
struct grid *gd = s->grid;
Change pane redraw to collect cells up as well, and simplify it a bit.
2017-02-21 16:25:04 +00:00
struct grid_cell gc, last;
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
const struct grid_cell *gcp;
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
struct grid_line *gl;
u_int i, j, ux, sx, width;
Fix check for wrapping when redrawing entire lines, GitHub issue 1836.
2019-07-16 14:11:52 +00:00
int flags, cleared = 0, wrapped = 0;
Change pane redraw to collect cells up as well, and simplify it a bit.
2017-02-21 16:25:04 +00:00
char buf[512];
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
size_t len;
Add accessors for grid linedata member, for some future work. From Dan Aloni.
2018-07-04 09:44:07 +00:00
u_int cellsize;
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
log_debug("%s: px=%u py=%u nx=%u atx=%u aty=%u", __func__,
px, py, nx, atx, aty);
/*
* py is the line in the screen to draw.
* px is the start x and nx is the width to draw.
* atx,aty is the line on the terminal to draw it.
*/
Use EL1 to clear lines when redrawing the leftmost pane, rather than spaces.
2017-04-16 20:32:14 +00:00
flags = (tty->flags & TTY_NOCURSOR);
Turn cursor off during redraw, pointed out by George Nachman.
2015-05-06 07:52:06 +00:00
tty->flags |= TTY_NOCURSOR;
tty_update_mode(tty, tty->mode, s);
Be less aggressive about turning the cursor off, only explicitly turn it off when tmux is redrawing, otherwise leave in the state set by the application.
2009-10-09 07:23:28 +00:00
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
tty_region_off(tty);
tty_margin_off(tty);
Need to redraw out to cellsize (total cells used in a line) rather than cellused (only non-space cells) because there may be cells with a nondefault background.
2017-05-11 11:38:49 +00:00
/*
* Clamp the width to cellsize - note this is not cellused, because
* there may be empty background cells after it (from BCE).
*/
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
sx = screen_size_x(s);
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 (nx > sx)
nx = sx;
Add accessors for grid linedata member, for some future work. From Dan Aloni.
2018-07-04 09:44:07 +00:00
cellsize = grid_get_line(gd, gd->hsize + py)->cellsize;
if (sx > cellsize)
sx = cellsize;
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
if (sx > tty->sx)
sx = tty->sx;
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 > nx)
sx = nx;
Use the actual width written rather than the possible width to clear.
2017-07-21 22:55:45 +00:00
ux = 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
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 (py == 0)
gl = NULL;
else
gl = grid_get_line(gd, gd->hsize + py - 1);
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if (gl == NULL ||
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
(~gl->flags & GRID_LINE_WRAPPED) ||
atx != 0 ||
Make full width panes try to play more nicely with terminal copy and paste by avoiding explicit line wraps if we think the terminal will wrap anyway.
2017-04-25 18:30:29 +00:00
tty->cx < tty->sx ||
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
nx < tty->sx) {
if (nx < tty->sx &&
atx == 0 &&
px + sx != nx &&
Make full width panes try to play more nicely with terminal copy and paste by avoiding explicit line wraps if we think the terminal will wrap anyway.
2017-04-25 18:30:29 +00:00
tty_term_has(tty->term, TTYC_EL1) &&
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
!tty_fake_bce(tty, defaults, 8)) {
tty_default_attributes(tty, defaults, palette, 8);
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
tty_cursor(tty, nx - 1, aty);
Make full width panes try to play more nicely with terminal copy and paste by avoiding explicit line wraps if we think the terminal will wrap anyway.
2017-04-25 18:30:29 +00:00
tty_putcode(tty, TTYC_EL1);
cleared = 1;
}
Fix check for wrapping when redrawing entire lines, GitHub issue 1836.
2019-07-16 14:11:52 +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
log_debug("%s: wrapped line %u", __func__, aty);
Fix check for wrapping when redrawing entire lines, GitHub issue 1836.
2019-07-16 14:11:52 +00:00
wrapped = 1;
}
Change pane redraw to collect cells up as well, and simplify it a bit.
2017-02-21 16:25:04 +00:00
memcpy(&last, &grid_default_cell, sizeof last);
len = 0;
width = 0;
When drawing lines that have wrapped naturally, don't force a newline but permit them to wrap naturally again. This allows terminals that use this to guess where lines start and end for eg mouse selecting (like xterm) to work correctly. This was another long-standing issue raised by several people over the last while. Thanks to martynas@ for much testing. This was not trivial to get right so bringing it in for wider testing and adn to fix any further glitches in-tree.
2009-10-12 17:19:47 +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
for (i = 0; i < sx; i++) {
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
grid_view_get_cell(gd, px + i, py, &gc);
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
gcp = tty_check_codeset(tty, &gc);
Change pane redraw to collect cells up as well, and simplify it a bit.
2017-02-21 16:25:04 +00:00
if (len != 0 &&
Add support for overlay popup boxes to show text or output temporarily above the normal layout. These work similarly to menus and are created with the display-popup command.
2020-03-24 08:09:43 +00:00
(!tty_check_overlay(tty, atx + ux + width, aty) ||
(gcp->attr & GRID_ATTR_CHARSET) ||
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
gcp->flags != last.flags ||
gcp->attr != last.attr ||
gcp->fg != last.fg ||
gcp->bg != last.bg ||
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
gcp->us != last.us ||
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
ux + width + gcp->data.width > nx ||
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
(sizeof buf) - len < gcp->data.size)) {
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_attributes(tty, &last, defaults, palette);
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
if (last.flags & GRID_FLAG_CLEARED) {
log_debug("%s: %zu cleared", __func__, len);
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_clear_line(tty, defaults, aty, atx + ux,
width, last.bg);
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
} else {
Fix check for wrapping when redrawing entire lines, GitHub issue 1836.
2019-07-16 14:11:52 +00:00
if (!wrapped || atx != 0 || ux != 0)
tty_cursor(tty, atx + ux, aty);
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
tty_putn(tty, buf, len, width);
}
Use the actual width written rather than the possible width to clear.
2017-07-21 22:55:45 +00:00
ux += width;
Change pane redraw to collect cells up as well, and simplify it a bit.
2017-02-21 16:25:04 +00:00
len = 0;
width = 0;
Fix check for wrapping when redrawing entire lines, GitHub issue 1836.
2019-07-16 14:11:52 +00:00
wrapped = 0;
Change pane redraw to collect cells up as well, and simplify it a bit.
2017-02-21 16:25:04 +00:00
}
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
if (gcp->flags & GRID_FLAG_SELECTED)
Fix drawing of ACS characters (they need to go character-at-a-time), accidentally broken in last commit.
2018-01-16 17:03:18 +00:00
screen_select_cell(s, &last, gcp);
Change pane redraw to collect cells up as well, and simplify it a bit.
2017-02-21 16:25:04 +00:00
else
Fix drawing of ACS characters (they need to go character-at-a-time), accidentally broken in last commit.
2018-01-16 17:03:18 +00:00
memcpy(&last, gcp, sizeof last);
Move the code to set up a padding cell into grid.c.
2020-06-02 20:51:46 +00:00
if (!tty_check_overlay(tty, atx + ux, aty)) {
if (~gcp->flags & GRID_FLAG_PADDING)
ux += gcp->data.width;
} else if (ux + gcp->data.width > nx) {
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_attributes(tty, &last, defaults, palette);
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
tty_cursor(tty, atx + ux, aty);
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
for (j = 0; j < gcp->data.width; j++) {
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 (ux + j > nx)
If there is a double width character at the very end of the line with not enough room to draw it, just leave it out.
2017-11-15 19:18:57 +00:00
break;
tty_putc(tty, ' ');
ux++;
}
Fix drawing of ACS characters (they need to go character-at-a-time), accidentally broken in last commit.
2018-01-16 17:03:18 +00:00
} else if (gcp->attr & GRID_ATTR_CHARSET) {
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_attributes(tty, &last, defaults, palette);
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
tty_cursor(tty, atx + ux, aty);
Fix drawing of ACS characters (they need to go character-at-a-time), accidentally broken in last commit.
2018-01-16 17:03:18 +00:00
for (j = 0; j < gcp->data.size; j++)
tty_putc(tty, gcp->data.data[j]);
Add support for overlay popup boxes to show text or output temporarily above the normal layout. These work similarly to menus and are created with the display-popup command.
2020-03-24 08:09:43 +00:00
ux += gcp->data.width;
Move the code to set up a padding cell into grid.c.
2020-06-02 20:51:46 +00:00
} else if (~gcp->flags & GRID_FLAG_PADDING) {
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
memcpy(buf + len, gcp->data.data, gcp->data.size);
len += gcp->data.size;
width += gcp->data.width;
Change pane redraw to collect cells up as well, and simplify it a bit.
2017-02-21 16:25:04 +00:00
}
}
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
if (len != 0 && ((~last.flags & GRID_FLAG_CLEARED) || last.bg != 8)) {
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_attributes(tty, &last, defaults, palette);
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
if (last.flags & GRID_FLAG_CLEARED) {
log_debug("%s: %zu cleared (end)", __func__, len);
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_clear_line(tty, defaults, aty, atx + ux, width,
last.bg);
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
} else {
Fix check for wrapping when redrawing entire lines, GitHub issue 1836.
2019-07-16 14:11:52 +00:00
if (!wrapped || atx != 0 || ux != 0)
tty_cursor(tty, atx + ux, aty);
Trim trailing spaces from full line when it is clearly OK to do so.
2017-07-21 14:25:29 +00:00
tty_putn(tty, buf, len, width);
}
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
ux += width;
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
if (!cleared && ux < nx) {
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
log_debug("%s: %u to end of line (%zu cleared)", __func__,
nx - ux, len);
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, defaults, palette, 8);
tty_clear_line(tty, defaults, aty, atx + ux, nx - ux, 8);
Be less aggressive about turning the cursor off, only explicitly turn it off when tmux is redrawing, otherwise leave in the state set by the application.
2009-10-09 07:23:28 +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
Turn cursor off during redraw, pointed out by George Nachman.
2015-05-06 07:52:06 +00:00
tty->flags = (tty->flags & ~TTY_NOCURSOR) | flags;
Support xterm(1) cursor colour change sequences through terminfo(5) Cc (set) and Cr (reset) extensions. Originally by Sean Estabrooks, tweaked by me and Ailin Nemui.
2011-05-20 19:03:58 +00:00
tty_update_mode(tty, tty->mode, 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
}
Add support for the iTerm2 sychronized updates escape sequence which drastically reduces flickering.
2020-04-16 13:35:24 +00:00
void
tty_sync_start(struct tty *tty)
{
Change how sync works to always send the end sequence after all output is done when we are returning to the event loop (since we always move the cursor at that point). Also a man fix from jmc.
2020-04-20 14:59:31 +00:00
if (tty->flags & TTY_BLOCK)
return;
if (tty->flags & TTY_SYNCING)
return;
tty->flags |= TTY_SYNCING;
if (tty_term_has(tty->term, TTYC_SYNC)) {
log_debug("%s sync start", tty->client->name);
Change the Sync capability to be a string instead of a flag.
2020-04-20 13:38:48 +00:00
tty_putcode1(tty, TTYC_SYNC, 1);
Add a flag to protect against nested syncs and add some extra logging to redrawing.
2020-04-18 06:20:50 +00:00
}
Add support for the iTerm2 sychronized updates escape sequence which drastically reduces flickering.
2020-04-16 13:35:24 +00:00
}
void
tty_sync_end(struct tty *tty)
{
Change how sync works to always send the end sequence after all output is done when we are returning to the event loop (since we always move the cursor at that point). Also a man fix from jmc.
2020-04-20 14:59:31 +00:00
if (tty->flags & TTY_BLOCK)
return;
if (~tty->flags & TTY_SYNCING)
return;
tty->flags &= ~TTY_SYNCING;
if (tty_term_has(tty->term, TTYC_SYNC)) {
log_debug("%s sync end", tty->client->name);
Change the Sync capability to be a string instead of a flag.
2020-04-20 13:38:48 +00:00
tty_putcode1(tty, TTYC_SYNC, 2);
Add a flag to protect against nested syncs and add some extra logging to redrawing.
2020-04-18 06:20:50 +00:00
}
Add support for the iTerm2 sychronized updates escape sequence which drastically reduces flickering.
2020-04-16 13:35:24 +00:00
}
tty_client_ready can not be internal to tty.c again.
2016-04-30 18:59:02 +00:00
static int
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_client_ready(struct client *c)
To replace c0-*, add a high watermark to the pty event, and also backoff when the any of the ttys the pane is going to write to has buffered enough data.
2015-05-12 22:40:38 +00:00
{
if (c->session == NULL || c->tty.term == NULL)
return (0);
Add a client redraw-window flag instead of the redraw-all flag and for all just use the three flags together (window, borders, status).
2018-08-19 16:45:03 +00:00
if (c->flags & (CLIENT_REDRAWWINDOW|CLIENT_SUSPENDED))
To replace c0-*, add a high watermark to the pty event, and also backoff when the any of the ttys the pane is going to write to has buffered enough data.
2015-05-12 22:40:38 +00:00
return (0);
if (c->tty.flags & TTY_FREEZE)
return (0);
return (1);
}
tty_write is relatively short and the only function left in tty-write.c so move it into tty.c.
2009-07-22 20:56:58 +00:00
void
To replace c0-*, add a high watermark to the pty event, and also backoff when the any of the ttys the pane is going to write to has buffered enough data.
2015-05-12 22:40:38 +00:00
tty_write(void (*cmdfn)(struct tty *, const struct tty_ctx *),
struct tty_ctx *ctx)
tty_write is relatively short and the only function left in tty-write.c so move it into tty.c.
2009-07-22 20:56:58 +00:00
{
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
struct client *c;
int state;
tty_write is relatively short and the only function left in tty-write.c so move it into tty.c.
2009-07-22 20:56:58 +00:00
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if (ctx->set_client_cb == NULL)
tty_write is relatively short and the only function left in tty-write.c so move it into tty.c.
2009-07-22 20:56:58 +00:00
return;
Convert clients list into a TAILQ.
2015-04-24 23:17:11 +00:00
TAILQ_FOREACH(c, &clients, entry) {
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if (!tty_client_ready(c))
tty_write is relatively short and the only function left in tty-write.c so move it into tty.c.
2009-07-22 20:56:58 +00:00
continue;
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
state = ctx->set_client_cb(ctx, c);
if (state == -1)
Bring back previons fix to only redraw panes that need it after a redraw is deferred, but clear the pane flags when they are actually redrawn rather than every time.
2020-04-18 07:32:53 +00:00
break;
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if (state == 0)
continue;
Tidy up tty_write, from Sean Estabrooks.
2012-08-14 08:58:25 +00:00
cmdfn(&c->tty, ctx);
tty_write is relatively short and the only function left in tty-write.c so move it into tty.c.
2009-07-22 20:56:58 +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
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_insertcharacter(struct tty *tty, const struct tty_ctx *ctx)
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
if (ctx->bigger ||
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
!tty_full_width(tty, ctx) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_fake_bce(tty, &ctx->defaults, ctx->bg) ||
Add support for BCE (background colour erase). This makes various escape sequences (notable EL and ED but also IL, DL, ICH, DCH) create blank cells using the current background colour rather than the default colour. On modern systems BCE doesn't really have many benefits, but most other terminals now support it, some (lazy) applications rely on it, and it is not hard to include now that we have pane background colours anyway. Mostly written by Sean Haugh.
2016-10-13 20:27:27 +00:00
(!tty_term_has(tty->term, TTYC_ICH) &&
!tty_term_has(tty->term, TTYC_ICH1))) {
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
tty_draw_pane(tty, ctx, ctx->ocy);
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
return;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
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
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
Similarly add a tty_cursor_pane function to tidy up most of the calls.
2009-10-12 09:29:58 +00:00
Remove some redundant checks and make ich/dch consistent.
2016-10-03 19:19:18 +00:00
tty_emulate_repeat(tty, TTYC_ICH, TTYC_ICH1, ctx->num);
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
}
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_deletecharacter(struct tty *tty, const struct tty_ctx *ctx)
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
if (ctx->bigger ||
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
!tty_full_width(tty, ctx) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_fake_bce(tty, &ctx->defaults, ctx->bg) ||
Emulate dch/dch1 if missing by redrawing the entire line.
2009-08-21 12:29:59 +00:00
(!tty_term_has(tty->term, TTYC_DCH) &&
!tty_term_has(tty->term, TTYC_DCH1))) {
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
tty_draw_pane(tty, ctx, ctx->ocy);
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
return;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
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
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
Similarly add a tty_cursor_pane function to tidy up most of the calls.
2009-10-12 09:29:58 +00:00
Remove some redundant checks and make ich/dch consistent.
2016-10-03 19:19:18 +00:00
tty_emulate_repeat(tty, TTYC_DCH, TTYC_DCH1, ctx->num);
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
}
Implement ECH (erase character, CSI X). Reported by Christian Neukirchen.
2013-01-15 23:18:55 +00:00
void
tty_cmd_clearcharacter(struct tty *tty, const struct tty_ctx *ctx)
{
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
Implement ECH (erase character, CSI X). Reported by Christian Neukirchen.
2013-01-15 23:18:55 +00:00
There is no need to clear every line entirely before drawing to it, this means moving the cursor and messes up wrapping. Better to just clear the sections that aren't written over. GitHub issue 2537.
2021-01-18 10:27:54 +00:00
tty_clear_pane_line(tty, ctx, ctx->ocy, ctx->ocx, ctx->num, ctx->bg);
Implement ECH (erase character, CSI X). Reported by Christian Neukirchen.
2013-01-15 23:18:55 +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
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_insertline(struct tty *tty, const struct tty_ctx *ctx)
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
if (ctx->bigger ||
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
!tty_full_width(tty, ctx) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_fake_bce(tty, &ctx->defaults, ctx->bg) ||
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
!tty_term_has(tty->term, TTYC_CSR) ||
Allow panes to be 1 line or column by redrawing instead of using the scroll region, from Soeren Tempel in GitHub issue 1487.
2018-09-25 14:27:20 +00:00
!tty_term_has(tty->term, TTYC_IL1) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
ctx->sx == 1 ||
ctx->sy == 1) {
More tty code tidying: move the saved cursor/region position (from before the screen was updated) out of struct screen and into struct tty_ctx.
2009-07-22 20:53:38 +00:00
tty_redraw_region(tty, ctx);
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
return;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
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
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
tty_margin_off(tty);
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
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
There are relatively few arguments to tty_cmd_* functions now, so tidy them up by using a struct rather than hiding everything with varargs.
2009-07-22 16:45:31 +00:00
tty_emulate_repeat(tty, TTYC_IL, TTYC_IL1, ctx->num);
Cannot rely on cursor position after DL and IL (some terminals move to column 0, some do not).
2017-05-12 14:13:54 +00:00
tty->cx = tty->cy = UINT_MAX;
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
}
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_deleteline(struct tty *tty, const struct tty_ctx *ctx)
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
if (ctx->bigger ||
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
!tty_full_width(tty, ctx) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_fake_bce(tty, &ctx->defaults, ctx->bg) ||
Emulate il1, dl1, ich1 to run (albeit slowly) with vt100 feature set.
2009-11-26 14:46:08 +00:00
!tty_term_has(tty->term, TTYC_CSR) ||
Allow panes to be 1 line or column by redrawing instead of using the scroll region, from Soeren Tempel in GitHub issue 1487.
2018-09-25 14:27:20 +00:00
!tty_term_has(tty->term, TTYC_DL1) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
ctx->sx == 1 ||
ctx->sy == 1) {
More tty code tidying: move the saved cursor/region position (from before the screen was updated) out of struct screen and into struct tty_ctx.
2009-07-22 20:53:38 +00:00
tty_redraw_region(tty, ctx);
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
return;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
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
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
tty_margin_off(tty);
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
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
There are relatively few arguments to tty_cmd_* functions now, so tidy them up by using a struct rather than hiding everything with varargs.
2009-07-22 16:45:31 +00:00
tty_emulate_repeat(tty, TTYC_DL, TTYC_DL1, ctx->num);
Cannot rely on cursor position after DL and IL (some terminals move to column 0, some do not).
2017-05-12 14:13:54 +00:00
tty->cx = tty->cy = UINT_MAX;
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
}
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_clearline(struct tty *tty, const struct tty_ctx *ctx)
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
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
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
tty_clear_pane_line(tty, ctx, ctx->ocy, 0, ctx->sx, ctx->bg);
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
}
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_clearendofline(struct tty *tty, const struct tty_ctx *ctx)
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
u_int nx = ctx->sx - ctx->ocx;
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
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
tty_clear_pane_line(tty, ctx, ctx->ocy, ctx->ocx, nx, ctx->bg);
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
}
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_clearstartofline(struct tty *tty, const struct tty_ctx *ctx)
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
Add support for BCE (background colour erase). This makes various escape sequences (notable EL and ED but also IL, DL, ICH, DCH) create blank cells using the current background colour rather than the default colour. On modern systems BCE doesn't really have many benefits, but most other terminals now support it, some (lazy) applications rely on it, and it is not hard to include now that we have pane background colours anyway. Mostly written by Sean Haugh.
2016-10-13 20:27:27 +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
tty_clear_pane_line(tty, ctx, ctx->ocy, 0, ctx->ocx + 1, ctx->bg);
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
}
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_reverseindex(struct tty *tty, const struct tty_ctx *ctx)
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
{
Don't redraw the scroll region on linefeed/reverse index unless it is necessary (the cursor is at the bottom/top). Should fix slow cursor movement when using vi in a pane spotted by pirofti@.
2009-10-21 13:42:44 +00:00
if (ctx->ocy != ctx->orupper)
return;
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 (ctx->bigger ||
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
(!tty_full_width(tty, ctx) && !tty_use_margin(tty)) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_fake_bce(tty, &ctx->defaults, 8) ||
Emulate the ri (reverse index) capability: this allows tmux to at least start on Sun consoles (TERM=sun or sun-color), even if there appear to still be problems on some boxes (my Blade 100 is fine but edd's Blade 1000 shows odd screen corruption).
2009-11-12 08:05:23 +00:00
!tty_term_has(tty->term, TTYC_CSR) ||
Add support for the SD (scroll down) escape sequence, GitHub issue 1861.
2019-08-05 06:42:02 +00:00
(!tty_term_has(tty->term, TTYC_RI) &&
!tty_term_has(tty->term, TTYC_RIN)) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
ctx->sx == 1 ||
ctx->sy == 1) {
More tty code tidying: move the saved cursor/region position (from before the screen was updated) out of struct screen and into struct tty_ctx.
2009-07-22 20:53:38 +00:00
tty_redraw_region(tty, ctx);
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
return;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
Don't redraw the scroll region on linefeed/reverse index unless it is necessary (the cursor is at the bottom/top). Should fix slow cursor movement when using vi in a pane spotted by pirofti@.
2009-10-21 13:42:44 +00:00
tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
Add support for the SD (scroll down) escape sequence, GitHub issue 1861.
2019-08-05 06:42:02 +00:00
tty_margin_pane(tty, ctx);
Don't redraw the scroll region on linefeed/reverse index unless it is necessary (the cursor is at the bottom/top). Should fix slow cursor movement when using vi in a pane spotted by pirofti@.
2009-10-21 13:42:44 +00:00
tty_cursor_pane(tty, ctx, ctx->ocx, ctx->orupper);
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
Add support for the SD (scroll down) escape sequence, GitHub issue 1861.
2019-08-05 06:42:02 +00:00
if (tty_term_has(tty->term, TTYC_RI))
tty_putcode(tty, TTYC_RI);
else
tty_putcode1(tty, TTYC_RIN, 1);
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
}
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_linefeed(struct tty *tty, const struct tty_ctx *ctx)
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
{
Don't redraw the scroll region on linefeed/reverse index unless it is necessary (the cursor is at the bottom/top). Should fix slow cursor movement when using vi in a pane spotted by pirofti@.
2009-10-21 13:42:44 +00:00
if (ctx->ocy != ctx->orlower)
return;
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 (ctx->bigger ||
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
(!tty_full_width(tty, ctx) && !tty_use_margin(tty)) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_fake_bce(tty, &ctx->defaults, 8) ||
Allow panes to be 1 line or column by redrawing instead of using the scroll region, from Soeren Tempel in GitHub issue 1487.
2018-09-25 14:27:20 +00:00
!tty_term_has(tty->term, TTYC_CSR) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
ctx->sx == 1 ||
ctx->sy == 1) {
Remove unnecessary duplicate check.
2017-02-08 15:24:48 +00:00
tty_redraw_region(tty, ctx);
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
return;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
Don't redraw the scroll region on linefeed/reverse index unless it is necessary (the cursor is at the bottom/top). Should fix slow cursor movement when using vi in a pane spotted by pirofti@.
2009-10-21 13:42:44 +00:00
tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
tty_margin_pane(tty, ctx);
/*
rxvt-unicode has some funny behaviour when scrolling with the cursor not at column 1, so move it back there first if possible. GitHub issue 1318.
2018-04-23 07:41:30 +00:00
* If we want to wrap a pane while using margins, the cursor needs to
* be exactly on the right of the region. If the cursor is entirely off
* the edge - move it back to the right. Some terminals are funny about
* this and insert extra spaces, so only use the right if margins are
* enabled.
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
*/
rxvt-unicode has some funny behaviour when scrolling with the cursor not at column 1, so move it back there first if possible. GitHub issue 1318.
2018-04-23 07:41:30 +00:00
if (ctx->xoff + ctx->ocx > tty->rright) {
if (!tty_use_margin(tty))
tty_cursor(tty, 0, ctx->yoff + ctx->ocy);
else
tty_cursor(tty, tty->rright, ctx->yoff + ctx->ocy);
} else
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
Don't redraw the scroll region on linefeed/reverse index unless it is necessary (the cursor is at the bottom/top). Should fix slow cursor movement when using vi in a pane spotted by pirofti@.
2009-10-21 13:42:44 +00:00
tty_putc(tty, '\n');
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
}
Add support for scroll up escape sequence (CSI S) and use it when possible instead of sending individual line feeds.
2017-02-08 17:31:09 +00:00
void
tty_cmd_scrollup(struct tty *tty, const struct tty_ctx *ctx)
{
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
u_int i;
Add support for scroll up escape sequence (CSI S) and use it when possible instead of sending individual line feeds.
2017-02-08 17:31:09 +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
if (ctx->bigger ||
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
(!tty_full_width(tty, ctx) && !tty_use_margin(tty)) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_fake_bce(tty, &ctx->defaults, 8) ||
Allow panes to be 1 line or column by redrawing instead of using the scroll region, from Soeren Tempel in GitHub issue 1487.
2018-09-25 14:27:20 +00:00
!tty_term_has(tty->term, TTYC_CSR) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
ctx->sx == 1 ||
ctx->sy == 1) {
Add support for scroll up escape sequence (CSI S) and use it when possible instead of sending individual line feeds.
2017-02-08 17:31:09 +00:00
tty_redraw_region(tty, ctx);
return;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
Add support for scroll up escape sequence (CSI S) and use it when possible instead of sending individual line feeds.
2017-02-08 17:31:09 +00:00
tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
tty_margin_pane(tty, ctx);
The Konsole SU bug means it can't clear the entire scroll region (it ignores if >= size, not if > as I first thought). So we can't effectively fix it in code - remove the workarounds which just cause bugs on other terminals.
2017-05-15 07:54:44 +00:00
if (ctx->num == 1 || !tty_term_has(tty->term, TTYC_INDN)) {
rxvt-unicode has some funny behaviour when scrolling with the cursor not at column 1, so move it back there first if possible. GitHub issue 1318.
2018-04-23 07:41:30 +00:00
if (!tty_use_margin(tty))
tty_cursor(tty, 0, tty->rlower);
else
tty_cursor(tty, tty->rright, tty->rlower);
The Konsole SU bug means it can't clear the entire scroll region (it ignores if >= size, not if > as I first thought). So we can't effectively fix it in code - remove the workarounds which just cause bugs on other terminals.
2017-05-15 07:54:44 +00:00
for (i = 0; i < ctx->num; i++)
Add support for scroll up escape sequence (CSI S) and use it when possible instead of sending individual line feeds.
2017-02-08 17:31:09 +00:00
tty_putc(tty, '\n');
rxvt-unicode has some funny behaviour when scrolling with the cursor not at column 1, so move it back there first if possible. GitHub issue 1318.
2018-04-23 07:41:30 +00:00
} else {
Do not move the cursor to the existing y position if it is invalid, go home instead.
2020-04-17 21:33:18 +00:00
if (tty->cy == UINT_MAX)
tty_cursor(tty, 0, 0);
else
tty_cursor(tty, 0, tty->cy);
The Konsole SU bug means it can't clear the entire scroll region (it ignores if >= size, not if > as I first thought). So we can't effectively fix it in code - remove the workarounds which just cause bugs on other terminals.
2017-05-15 07:54:44 +00:00
tty_putcode1(tty, TTYC_INDN, ctx->num);
rxvt-unicode has some funny behaviour when scrolling with the cursor not at column 1, so move it back there first if possible. GitHub issue 1318.
2018-04-23 07:41:30 +00:00
}
Add support for scroll up escape sequence (CSI S) and use it when possible instead of sending individual line feeds.
2017-02-08 17:31:09 +00:00
}
Add support for the SD (scroll down) escape sequence, GitHub issue 1861.
2019-08-05 06:42:02 +00:00
void
tty_cmd_scrolldown(struct tty *tty, const struct tty_ctx *ctx)
{
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
u_int i;
Add support for the SD (scroll down) escape sequence, GitHub issue 1861.
2019-08-05 06:42:02 +00:00
if (ctx->bigger ||
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
(!tty_full_width(tty, ctx) && !tty_use_margin(tty)) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_fake_bce(tty, &ctx->defaults, 8) ||
Add support for the SD (scroll down) escape sequence, GitHub issue 1861.
2019-08-05 06:42:02 +00:00
!tty_term_has(tty->term, TTYC_CSR) ||
(!tty_term_has(tty->term, TTYC_RI) &&
!tty_term_has(tty->term, TTYC_RIN)) ||
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
ctx->sx == 1 ||
ctx->sy == 1) {
Add support for the SD (scroll down) escape sequence, GitHub issue 1861.
2019-08-05 06:42:02 +00:00
tty_redraw_region(tty, ctx);
return;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
Add support for the SD (scroll down) escape sequence, GitHub issue 1861.
2019-08-05 06:42:02 +00:00
tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
tty_margin_pane(tty, ctx);
tty_cursor_pane(tty, ctx, ctx->ocx, ctx->orupper);
if (tty_term_has(tty->term, TTYC_RIN))
tty_putcode1(tty, TTYC_RIN, ctx->num);
else {
for (i = 0; i < ctx->num; i++)
tty_putcode(tty, TTYC_RI);
}
}
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
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_clearendofscreen(struct tty *tty, const struct tty_ctx *ctx)
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
u_int px, py, nx, ny;
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
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
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
tty_region_pane(tty, ctx, 0, ctx->sy - 1);
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
tty_margin_off(tty);
Cleanup: use two functions for region setting, one for absolute and one inside pane.
2009-10-12 09:09:35 +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
px = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
nx = ctx->sx;
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
py = ctx->ocy + 1;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
ny = ctx->sy - ctx->ocy - 1;
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
tty_clear_pane_area(tty, ctx, py, ny, px, nx, ctx->bg);
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
px = ctx->ocx;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
nx = ctx->sx - ctx->ocx;
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
py = ctx->ocy;
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
tty_clear_pane_line(tty, ctx, py, px, nx, ctx->bg);
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
}
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_clearstartofscreen(struct tty *tty, const struct tty_ctx *ctx)
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
u_int px, py, nx, ny;
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
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
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
tty_region_pane(tty, ctx, 0, ctx->sy - 1);
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
tty_margin_off(tty);
Cleanup: use two functions for region setting, one for absolute and one inside pane.
2009-10-12 09:09:35 +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
px = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
nx = ctx->sx;
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
py = 0;
Fix ED1 (clear end of screen), reported by Marc Reisner.
2019-03-14 17:58:52 +00:00
ny = ctx->ocy;
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
tty_clear_pane_area(tty, ctx, py, ny, px, nx, ctx->bg);
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
px = 0;
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +00:00
nx = ctx->ocx + 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
py = ctx->ocy;
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
tty_clear_pane_line(tty, ctx, py, px, nx, ctx->bg);
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
}
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_clearscreen(struct tty *tty, const struct tty_ctx *ctx)
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
u_int px, py, nx, ny;
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(tty, &ctx->defaults, ctx->palette, ctx->bg);
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
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
tty_region_pane(tty, ctx, 0, ctx->sy - 1);
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
tty_margin_off(tty);
Cleanup: use two functions for region setting, one for absolute and one inside pane.
2009-10-12 09:09:35 +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
px = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
nx = ctx->sx;
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
py = 0;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
ny = ctx->sy;
We can use ECH to clear sections of lines, so use it for internal panes (that don't touch an edge). Move all the tty clear code into two common functions rather than having the same bunch of checks everywhere.
2017-05-10 16:47:03 +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
tty_clear_pane_area(tty, ctx, py, ny, px, nx, ctx->bg);
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
}
Implement the DEC alignment test. With the last change this is enough for the first cursor test in vttest (in ports) to pass; it still shops a few more problems though.
2009-06-03 23:30:40 +00:00
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_alignmenttest(struct tty *tty, const struct tty_ctx *ctx)
Implement the DEC alignment test. With the last change this is enough for the first cursor test in vttest (in ports) to pass; it still shops a few more problems though.
2009-06-03 23:30:40 +00:00
{
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
u_int i, j;
Implement the DEC alignment test. With the last change this is enough for the first cursor test in vttest (in ports) to pass; it still shops a few more problems though.
2009-06-03 23:30:40 +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
if (ctx->bigger) {
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
ctx->redraw_cb(ctx);
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
return;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_attributes(tty, &grid_default_cell, &ctx->defaults, ctx->palette);
Implement the DEC alignment test. With the last change this is enough for the first cursor test in vttest (in ports) to pass; it still shops a few more problems though.
2009-06-03 23:30:40 +00:00
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
tty_region_pane(tty, ctx, 0, ctx->sy - 1);
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
tty_margin_off(tty);
Implement the DEC alignment test. With the last change this is enough for the first cursor test in vttest (in ports) to pass; it still shops a few more problems though.
2009-06-03 23:30:40 +00:00
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
for (j = 0; j < ctx->sy; j++) {
Similarly add a tty_cursor_pane function to tidy up most of the calls.
2009-10-12 09:29:58 +00:00
tty_cursor_pane(tty, ctx, 0, j);
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
for (i = 0; i < ctx->sx; i++)
Implement the DEC alignment test. With the last change this is enough for the first cursor test in vttest (in ports) to pass; it still shops a few more problems though.
2009-06-03 23:30:40 +00:00
tty_putc(tty, 'E');
}
}
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
void
A tty context must not be modified as it may be reused to update multiple clients, so make it const. Also fix an actual modification which caused a hang when a session was connected to multiple terminals at least one of which was missing ich/ich1.
2009-08-12 09:41:59 +00:00
tty_cmd_cell(struct tty *tty, const struct tty_ctx *ctx)
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
if (!tty_is_visible(tty, ctx, ctx->ocx, ctx->ocy, 1, 1))
return;
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
if (ctx->xoff + ctx->ocx - ctx->wox > tty->sx - 1 &&
The cursor position is limited to the margins for CUF and CUB, so turn margins off for printing cells (like most everything else already does). Problem reported by Thomas Sattler.
2018-09-11 17:31:01 +00:00
ctx->ocy == ctx->orlower &&
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
tty_full_width(tty, ctx))
The cursor position is limited to the margins for CUF and CUB, so turn margins off for printing cells (like most everything else already does). Problem reported by Thomas Sattler.
2018-09-11 17:31:01 +00:00
tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
When drawing lines that have wrapped naturally, don't force a newline but permit them to wrap naturally again. This allows terminals that use this to guess where lines start and end for eg mouse selecting (like xterm) to work correctly. This was another long-standing issue raised by several people over the last while. Thanks to martynas@ for much testing. This was not trivial to get right so bringing it in for wider testing and adn to fix any further glitches in-tree.
2009-10-12 17:19:47 +00:00
The cursor position is limited to the margins for CUF and CUB, so turn margins off for printing cells (like most everything else already does). Problem reported by Thomas Sattler.
2018-09-11 17:31:01 +00:00
tty_margin_off(tty);
Try to avoid moving the cursor to the start of the next line when printing cells if it is already at the very end of the line and the terminal will wrap it to the next line itself, this means terminals still see it as a wrapped line for the purposes of their own mouse selection. Reported by millert@.
2017-03-15 09:21:21 +00:00
tty_cursor_pane_unless_wrap(tty, ctx, ctx->ocx, ctx->ocy);
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 hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_cell(tty, ctx->cell, &ctx->defaults, ctx->palette);
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
}
Collect sequences of printable ASCII characters and process them together instead of handling them one by one. This is significantly faster. Sequences are terminated when we reach the end of the line, fill the internal buffer, or a different character is seen by the input parser (an escape sequence, or UTF-8). Rather than writing collected sequences out immediately, hold them until it is necessary (another screen modification, or we consume all available data). This means we can discard changes that would have no effect (for example, lines that would just be scrolled off the screen or cleared). This reduces the total amount of data we write out to the terminal - not important for fast terminals, but a big help with slow (like xterm).
2017-02-08 16:45:18 +00:00
void
tty_cmd_cells(struct tty *tty, const struct tty_ctx *ctx)
{
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 (!tty_is_visible(tty, ctx, ctx->ocx, ctx->ocy, ctx->num, 1))
return;
if (ctx->bigger &&
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
(ctx->xoff + ctx->ocx < ctx->wox ||
ctx->xoff + ctx->ocx + ctx->num > ctx->wox + ctx->wsx)) {
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 (!ctx->wrapped ||
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
!tty_full_width(tty, ctx) ||
Fix various confusion about am vs xenl.
2020-06-05 09:32:15 +00:00
(tty->term->flags & TERM_NOAM) ||
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
ctx->xoff + ctx->ocx != 0 ||
ctx->yoff + ctx->ocy != tty->cy + 1 ||
tty->cx < tty->sx ||
tty->cy == tty->rlower)
tty_draw_pane(tty, ctx, ctx->ocy);
else
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
ctx->redraw_cb(ctx);
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
return;
}
The cursor position is limited to the margins for CUF and CUB, so turn margins off for printing cells (like most everything else already does). Problem reported by Thomas Sattler.
2018-09-11 17:31:01 +00:00
tty_margin_off(tty);
Try to avoid moving the cursor to the start of the next line when printing cells if it is already at the very end of the line and the terminal will wrap it to the next line itself, this means terminals still see it as a wrapped line for the purposes of their own mouse selection. Reported by millert@.
2017-03-15 09:21:21 +00:00
tty_cursor_pane_unless_wrap(tty, ctx, ctx->ocx, ctx->ocy);
Collect sequences of printable ASCII characters and process them together instead of handling them one by one. This is significantly faster. Sequences are terminated when we reach the end of the line, fill the internal buffer, or a different character is seen by the input parser (an escape sequence, or UTF-8). Rather than writing collected sequences out immediately, hold them until it is necessary (another screen modification, or we consume all available data). This means we can discard changes that would have no effect (for example, lines that would just be scrolled off the screen or cleared). This reduces the total amount of data we write out to the terminal - not important for fast terminals, but a big help with slow (like xterm).
2017-02-08 16:45:18 +00:00
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_attributes(tty, ctx->cell, &ctx->defaults, ctx->palette);
Collect sequences of printable ASCII characters and process them together instead of handling them one by one. This is significantly faster. Sequences are terminated when we reach the end of the line, fill the internal buffer, or a different character is seen by the input parser (an escape sequence, or UTF-8). Rather than writing collected sequences out immediately, hold them until it is necessary (another screen modification, or we consume all available data). This means we can discard changes that would have no effect (for example, lines that would just be scrolled off the screen or cleared). This reduces the total amount of data we write out to the terminal - not important for fast terminals, but a big help with slow (like xterm).
2017-02-08 16:45:18 +00:00
tty_putn(tty, ctx->ptr, ctx->num, ctx->num);
}
Support setting the xterm clipboard when copying from copy mode using the xterm escape sequence for the purpose (if xterm is configured to allow it). Written by and much discussed Ailin Nemui, guidance on xterm/termcap/terminfo from Thomas Dickey.
2011-05-18 20:24:29 +00:00
void
tty_cmd_setselection(struct tty *tty, const struct tty_ctx *ctx)
{
Add a -w flag to set- and load-buffer to send to clipboard using OSC 52. GitHub issue 2363.
2020-09-02 13:46:35 +00:00
tty_set_selection(tty, ctx->ptr, ctx->num);
}
void
tty_set_selection(struct tty *tty, const char *buf, size_t len)
{
char *encoded;
size_t size;
Support setting the xterm clipboard when copying from copy mode using the xterm escape sequence for the purpose (if xterm is configured to allow it). Written by and much discussed Ailin Nemui, guidance on xterm/termcap/terminfo from Thomas Dickey.
2011-05-18 20:24:29 +00:00
Add a -w flag to set- and load-buffer to send to clipboard using OSC 52. GitHub issue 2363.
2020-09-02 13:46:35 +00:00
if (~tty->flags & TTY_STARTED)
return;
Check started flag before looking for capability.
2020-09-02 17:19:58 +00:00
if (!tty_term_has(tty->term, TTYC_MS))
return;
Support setting the xterm clipboard when copying from copy mode using the xterm escape sequence for the purpose (if xterm is configured to allow it). Written by and much discussed Ailin Nemui, guidance on xterm/termcap/terminfo from Thomas Dickey.
2011-05-18 20:24:29 +00:00
Add a -w flag to set- and load-buffer to send to clipboard using OSC 52. GitHub issue 2363.
2020-09-02 13:46:35 +00:00
size = 4 * ((len + 2) / 3) + 1; /* storage for base64 */
encoded = xmalloc(size);
Support setting the xterm clipboard when copying from copy mode using the xterm escape sequence for the purpose (if xterm is configured to allow it). Written by and much discussed Ailin Nemui, guidance on xterm/termcap/terminfo from Thomas Dickey.
2011-05-18 20:24:29 +00:00
Add a -w flag to set- and load-buffer to send to clipboard using OSC 52. GitHub issue 2363.
2020-09-02 13:46:35 +00:00
b64_ntop(buf, len, encoded, size);
tty_putcode_ptr2(tty, TTYC_MS, "", encoded);
Support setting the xterm clipboard when copying from copy mode using the xterm escape sequence for the purpose (if xterm is configured to allow it). Written by and much discussed Ailin Nemui, guidance on xterm/termcap/terminfo from Thomas Dickey.
2011-05-18 20:24:29 +00:00
Add a -w flag to set- and load-buffer to send to clipboard using OSC 52. GitHub issue 2363.
2020-09-02 13:46:35 +00:00
free(encoded);
Support setting the xterm clipboard when copying from copy mode using the xterm escape sequence for the purpose (if xterm is configured to allow it). Written by and much discussed Ailin Nemui, guidance on xterm/termcap/terminfo from Thomas Dickey.
2011-05-18 20:24:29 +00:00
}
Support passing through escape sequences to the underlying terminal by using DCS with a "tmux;" prefix. Escape characters in the sequences must be doubled. For example: $ printf '\033Ptmux;\033\033]12;red\007\033\\' Will pass \033]12;red\007 to the terminal (and change the cursor colour in xterm). From Kevin Goodsell.
2011-03-07 23:46:27 +00:00
void
tty_cmd_rawstring(struct tty *tty, const struct tty_ctx *ctx)
{
Write raw strings in one go rather than character at a time.
2017-03-24 14:45:00 +00:00
tty_add(tty, ctx->ptr, ctx->num);
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
tty_invalidate(tty);
Support passing through escape sequences to the underlying terminal by using DCS with a "tmux;" prefix. Escape characters in the sequences must be doubled. For example: $ printf '\033Ptmux;\033\033]12;red\007\033\\' Will pass \033]12;red\007 to the terminal (and change the cursor colour in xterm). From Kevin Goodsell.
2011-03-07 23:46:27 +00:00
}
Add support for the iTerm2 sychronized updates escape sequence which drastically reduces flickering.
2020-04-16 13:35:24 +00:00
void
tty_cmd_syncstart(struct tty *tty, __unused const struct tty_ctx *ctx)
{
tty_sync_start(tty);
}
Add an option to set the pane border lines style from a choice of single lines (ACS or UTF-8), double or heavy (UTF-8), simple (plain ASCII) or number (the pane numbers). Lines that won't work on a non-UTF-8 terminal are translated back into ACS when they are output.
2020-05-16 16:26:34 +00:00
void
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_cell(struct tty *tty, const struct grid_cell *gc,
const struct grid_cell *defaults, int *palette)
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
{
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
const struct grid_cell *gcp;
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
/* Skip last character if terminal is stupid. */
Fix various confusion about am vs xenl.
2020-06-05 09:32:15 +00:00
if ((tty->term->flags & TERM_NOAM) &&
Don't make assumptions about line wrap on !xenl terminals, means that using a wrong TERM without xenl is not so broken if used on a sensible terminal.
2016-10-14 21:48:00 +00:00
tty->cy == tty->sy - 1 &&
tty->cx == tty->sx - 1)
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
return;
/* If this is a padding character, do nothing. */
if (gc->flags & GRID_FLAG_PADDING)
return;
Add an option to set the pane border lines style from a choice of single lines (ACS or UTF-8), double or heavy (UTF-8), simple (plain ASCII) or number (the pane numbers). Lines that won't work on a non-UTF-8 terminal are translated back into ACS when they are output.
2020-05-16 16:26:34 +00:00
/* Check the output codeset and apply attributes. */
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
gcp = tty_check_codeset(tty, gc);
Add an option to set the pane border lines style from a choice of single lines (ACS or UTF-8), double or heavy (UTF-8), simple (plain ASCII) or number (the pane numbers). Lines that won't work on a non-UTF-8 terminal are translated back into ACS when they are output.
2020-05-16 16:26:34 +00:00
tty_attributes(tty, gcp, defaults, palette);
/* If it is a single character, write with putc to handle ACS. */
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
if (gcp->data.size == 1) {
Add an option to set the pane border lines style from a choice of single lines (ACS or UTF-8), double or heavy (UTF-8), simple (plain ASCII) or number (the pane numbers). Lines that won't work on a non-UTF-8 terminal are translated back into ACS when they are output.
2020-05-16 16:26:34 +00:00
tty_attributes(tty, gcp, defaults, palette);
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
if (*gcp->data.data < 0x20 || *gcp->data.data == 0x7f)
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
return;
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
tty_putc(tty, *gcp->data.data);
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
return;
}
Rather than having two grids for each pane, one for ASCII and one for UTF-8, collapse the two together. Simplifies the code at the expense of more memory (which can probably be reduced again later).
2013-01-18 02:16:21 +00:00
/* Write the data. */
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
tty_putn(tty, gcp->data.data, gcp->data.size, gcp->data.width);
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
}
void
tty_reset(struct tty *tty)
{
struct grid_cell *gc = &tty->cell;
Do not go through the whole attributes setting process if the new cell is the same as the previous one.
2017-02-06 19:45:23 +00:00
if (!grid_cells_equal(gc, &grid_default_cell)) {
Check the terminfo(5) U8 capability and disable using UTF-8 for ACS if it is present and zero. This is useful for users with terminals or fonts that do not correctly support UTF-8 line drawing characters. GitHub issue 927, reported by Hiroaki Yamazoe and Akinori Hattori.
2017-05-15 16:44:04 +00:00
if ((gc->attr & GRID_ATTR_CHARSET) && tty_acs_needed(tty))
Do not go through the whole attributes setting process if the new cell is the same as the previous one.
2017-02-06 19:45:23 +00:00
tty_putcode(tty, TTYC_RMACS);
tty_putcode(tty, TTYC_SGR0);
memcpy(gc, &grid_default_cell, sizeof *gc);
}
memcpy(&tty->last_cell, &grid_default_cell, sizeof tty->last_cell);
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
}
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
static void
tty_invalidate(struct tty *tty)
{
memcpy(&tty->cell, &grid_default_cell, sizeof tty->cell);
memcpy(&tty->last_cell, &grid_default_cell, sizeof tty->last_cell);
tty->cx = tty->cy = UINT_MAX;
tty->rupper = tty->rleft = UINT_MAX;
tty->rlower = tty->rright = UINT_MAX;
if (tty->flags & TTY_STARTED) {
xterm 348 now disables margins when resized, so send DECLRMM again.
2019-08-01 11:45:34 +00:00
if (tty_use_margin(tty))
Add extension terminfo(5) capabilities for margins.
2020-05-16 14:22:51 +00:00
tty_putcode(tty, TTYC_ENMG);
Another helper function to write to terminal and log.
2017-02-08 23:53:03 +00:00
tty_putcode(tty, TTYC_SGR0);
tty->mode = ALL_MODES;
tty_update_mode(tty, MODE_CURSOR, NULL);
tty_cursor(tty, 0, 0);
tty_region_off(tty);
tty_margin_off(tty);
} else
tty->mode = MODE_CURSOR;
}
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
/* Turn off margin. */
void
tty_region_off(struct tty *tty)
{
tty_region(tty, 0, tty->sy - 1);
}
_absolute is redundant, just use tty_region.
2009-10-12 09:16:59 +00:00
/* Set region inside pane. */
Add static in window-*.c and move some internal functions out of tmux.h.
2016-10-11 13:21:59 +00:00
static void
Style nits and line wrapping of function declarations.
2015-12-11 16:37:21 +00:00
tty_region_pane(struct tty *tty, const struct tty_ctx *ctx, u_int rupper,
u_int rlower)
Cleanup: use two functions for region setting, one for absolute and one inside pane.
2009-10-12 09:09:35 +00:00
{
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
tty_region(tty, ctx->yoff + rupper - ctx->woy,
ctx->yoff + rlower - ctx->woy);
Cleanup: use two functions for region setting, one for absolute and one inside pane.
2009-10-12 09:09:35 +00:00
}
_absolute is redundant, just use tty_region.
2009-10-12 09:16:59 +00:00
/* Set region at absolute position. */
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
static void
_absolute is redundant, just use tty_region.
2009-10-12 09:16:59 +00:00
tty_region(struct tty *tty, u_int rupper, u_int rlower)
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
{
Cleanup: use two functions for region setting, one for absolute and one inside pane.
2009-10-12 09:09:35 +00:00
if (tty->rlower == rlower && tty->rupper == rupper)
return;
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
if (!tty_term_has(tty->term, TTYC_CSR))
return;
Cleanup: use two functions for region setting, one for absolute and one inside pane.
2009-10-12 09:09:35 +00:00
tty->rupper = rupper;
tty->rlower = rlower;
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
Some terminals don't correctly clear their let's-wrap flag after changing the scroll region (which moves the cursor to 0,0). This means that if the cursor was at the edge of the screen, any further output after scroll region change incorrectly causes a line wrap. Add a workaround to move the cursor to position 0 if it is at the screen edge before changing scroll region.
2009-10-21 09:36:53 +00:00
/*
* Some terminals (such as PuTTY) do not correctly reset the cursor to
* 0,0 if it is beyond the last column (they do not reset their wrap
* flag so further output causes a line feed). As a workaround, do an
* explicit move to 0 first.
*/
Do not move the cursor to the existing y position if it is invalid, go home instead.
2020-04-17 21:33:18 +00:00
if (tty->cx >= tty->sx) {
if (tty->cy == UINT_MAX)
tty_cursor(tty, 0, 0);
else
tty_cursor(tty, 0, tty->cy);
}
Some terminals don't correctly clear their let's-wrap flag after changing the scroll region (which moves the cursor to 0,0). This means that if the cursor was at the edge of the screen, any further output after scroll region change incorrectly causes a line wrap. Add a workaround to move the cursor to position 0 if it is at the screen edge before changing scroll region.
2009-10-21 09:36:53 +00:00
Cleanup: use two functions for region setting, one for absolute and one inside pane.
2009-10-12 09:09:35 +00:00
tty_putcode2(tty, TTYC_CSR, tty->rupper, tty->rlower);
There are buggy terminals out there that do not move the cursor to 0,0 after CSR, so invalidate the cursor position rather than assuming 0,0.
2017-02-16 12:56:01 +00:00
tty->cx = tty->cy = UINT_MAX;
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
}
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
/* Turn off margin. */
void
tty_margin_off(struct tty *tty)
{
tty_margin(tty, 0, tty->sx - 1);
}
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
/* Set margin inside pane. */
static void
tty_margin_pane(struct tty *tty, const struct tty_ctx *ctx)
{
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
tty_margin(tty, ctx->xoff - ctx->wox,
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
ctx->xoff + ctx->sx - 1 - ctx->wox);
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
}
/* Set margin at absolute position. */
Turn on margins, with a couple of fixes (only limit to the pane for line feeds, and do not move cursor to end for full width panes).
2016-11-15 15:17:28 +00:00
static void
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
tty_margin(struct tty *tty, u_int rleft, u_int rright)
{
if (!tty_use_margin(tty))
return;
if (tty->rleft == rleft && tty->rright == rright)
return;
Do not clear the scroll region, instead set it to the scroll region we actually want.
2017-02-07 18:27:46 +00:00
tty_putcode2(tty, TTYC_CSR, tty->rupper, tty->rlower);
DECSLRM in xterm(1) appears to have a quirk where it can generate an extra scroll of the entire terminal; issuing DECSTBM first prevents this. Do that for now.
2017-02-07 17:13:28 +00:00
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
tty->rleft = rleft;
tty->rright = rright;
Do not clear the scroll region, instead set it to the scroll region we actually want.
2017-02-07 18:27:46 +00:00
if (rleft == 0 && rright == tty->sx - 1)
Add extension terminfo(5) capabilities for margins.
2020-05-16 14:22:51 +00:00
tty_putcode(tty, TTYC_CLMG);
Do not clear the scroll region, instead set it to the scroll region we actually want.
2017-02-07 18:27:46 +00:00
else
Add extension terminfo(5) capabilities for margins.
2020-05-16 14:22:51 +00:00
tty_putcode2(tty, TTYC_CMG, rleft, rright);
There are buggy terminals out there that do not move the cursor to 0,0 after CSR, so invalidate the cursor position rather than assuming 0,0.
2017-02-16 12:56:01 +00:00
tty->cx = tty->cy = UINT_MAX;
Initial attempt to make use of left and right margins if the terminal supports them (that is, if it advertises itself as a VT420 - probably just xterm). These are the vertical equivalent of the scroll region and allow much faster scrolling of panes that do not take up the full width of the terminal.
2016-11-15 14:02:32 +00:00
}
Try to avoid moving the cursor to the start of the next line when printing cells if it is already at the very end of the line and the terminal will wrap it to the next line itself, this means terminals still see it as a wrapped line for the purposes of their own mouse selection. Reported by millert@.
2017-03-15 09:21:21 +00:00
/*
* Move the cursor, unless it would wrap itself when the next character is
* printed.
*/
static void
tty_cursor_pane_unless_wrap(struct tty *tty, const struct tty_ctx *ctx,
u_int cx, u_int cy)
{
Make full width panes try to play more nicely with terminal copy and paste by avoiding explicit line wraps if we think the terminal will wrap anyway.
2017-04-25 18:30:29 +00:00
if (!ctx->wrapped ||
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
!tty_full_width(tty, ctx) ||
Fix various confusion about am vs xenl.
2020-06-05 09:32:15 +00:00
(tty->term->flags & TERM_NOAM) ||
Try to avoid moving the cursor to the start of the next line when printing cells if it is already at the very end of the line and the terminal will wrap it to the next line itself, this means terminals still see it as a wrapped line for the purposes of their own mouse selection. Reported by millert@.
2017-03-15 09:21:21 +00:00
ctx->xoff + cx != 0 ||
ctx->yoff + cy != tty->cy + 1 ||
Invalidate the cursor when we think we should have wrapped.
2017-03-15 15:22:14 +00:00
tty->cx < tty->sx ||
tty->cy == tty->rlower)
Try to avoid moving the cursor to the start of the next line when printing cells if it is already at the very end of the line and the terminal will wrap it to the next line itself, this means terminals still see it as a wrapped line for the purposes of their own mouse selection. Reported by millert@.
2017-03-15 09:21:21 +00:00
tty_cursor_pane(tty, ctx, cx, cy);
else
log_debug("%s: will wrap at %u,%u", __func__, tty->cx, tty->cy);
}
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
/* Move cursor inside pane. */
Add static in window-*.c and move some internal functions out of tmux.h.
2016-10-11 13:21:59 +00:00
static void
Similarly add a tty_cursor_pane function to tidy up most of the calls.
2009-10-12 09:29:58 +00:00
tty_cursor_pane(struct tty *tty, const struct tty_ctx *ctx, u_int cx, u_int cy)
{
Rename and tidy some stuff in struct tty_ctx.
2020-05-16 15:27:08 +00:00
tty_cursor(tty, ctx->xoff + cx - ctx->wox, ctx->yoff + cy - ctx->woy);
Similarly add a tty_cursor_pane function to tidy up most of the calls.
2009-10-12 09:29:58 +00:00
}
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
/* Move cursor to absolute position. */
Similarly add a tty_cursor_pane function to tidy up most of the calls.
2009-10-12 09:29:58 +00:00
void
tty_cursor(struct tty *tty, u_int cx, u_int cy)
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 relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
struct tty_term *term = tty->term;
u_int thisx, thisy;
int change;
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
Set mode properly before and after redrawing, and don't bother calculating cursor position if it won't be used.
2020-04-17 22:16:28 +00:00
if (tty->flags & TTY_BLOCK)
return;
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
if (cx > tty->sx - 1)
cx = tty->sx - 1;
thisx = tty->cx;
thisy = tty->cy;
/* No change. */
if (cx == thisx && cy == thisy)
return;
Use absolute movement if right at the end of the line as it isn't a reliable place to move from relatively.
2009-10-12 14:54:19 +00:00
/* Very end of the line, just use absolute movement. */
if (thisx > tty->sx - 1)
goto absolute;
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
/* Move to home position (0, 0). */
if (cx == 0 && cy == 0 && tty_term_has(term, TTYC_HOME)) {
tty_putcode(tty, TTYC_HOME);
goto out;
}
/* Zero on the next line. */
Do not emit \r\n to move to column 0 if there are margins, because it will instead move to the margin left.
2017-08-21 21:01:21 +00:00
if (cx == 0 && cy == thisy + 1 && thisy != tty->rlower &&
(!tty_use_margin(tty) || tty->rleft == 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
tty_putc(tty, '\r');
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
tty_putc(tty, '\n');
goto out;
}
Don't run through the column unchanged case if the row was unchanged but there were no suitable optimisations, instead make it an else to fall through to absolute addressing.
2009-10-12 16:41:02 +00:00
/* Moving column or row. */
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
if (cy == thisy) {
Don't run through the column unchanged case if the row was unchanged but there were no suitable optimisations, instead make it an else to fall through to absolute addressing.
2009-10-12 16:41:02 +00:00
/*
* Moving column only, row staying the same.
*/
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
/* To left edge. */
Same as previous for \r alone.
2017-08-21 21:02:58 +00:00
if (cx == 0 && (!tty_use_margin(tty) || tty->rleft == 0)) {
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
tty_putc(tty, '\r');
goto out;
}
/* One to the left. */
if (cx == thisx - 1 && tty_term_has(term, TTYC_CUB1)) {
tty_putcode(tty, TTYC_CUB1);
goto out;
}
/* One to the right. */
if (cx == thisx + 1 && tty_term_has(term, TTYC_CUF1)) {
tty_putcode(tty, TTYC_CUF1);
goto out;
}
/* Calculate difference. */
change = thisx - cx; /* +ve left, -ve right */
/*
* Use HPA if change is larger than absolute, otherwise move
* the cursor with CUB/CUF.
*/
Shut up gcc4 warnings.
2010-06-05 16:32:22 +00:00
if ((u_int) abs(change) > cx && tty_term_has(term, TTYC_HPA)) {
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
tty_putcode1(tty, TTYC_HPA, cx);
goto out;
CUB and CUF are also limited by the margins so use CUP instead when margins are enabled (we already do this for linefeed).
2019-11-14 07:56:32 +00:00
} else if (change > 0 &&
tty_term_has(term, TTYC_CUB) &&
!tty_use_margin(tty)) {
Send two cub1 instead of using cub for moving the cursor two left. This is normally better because using cub1 will be ^H^H (so two bytes) but cub would be ^[[2D (four).
2016-05-30 09:26:49 +00:00
if (change == 2 && tty_term_has(term, TTYC_CUB1)) {
tty_putcode(tty, TTYC_CUB1);
tty_putcode(tty, TTYC_CUB1);
goto out;
}
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
tty_putcode1(tty, TTYC_CUB, change);
goto out;
CUB and CUF are also limited by the margins so use CUP instead when margins are enabled (we already do this for linefeed).
2019-11-14 07:56:32 +00:00
} else if (change < 0 &&
tty_term_has(term, TTYC_CUF) &&
!tty_use_margin(tty)) {
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
tty_putcode1(tty, TTYC_CUF, -change);
goto out;
}
Don't run through the column unchanged case if the row was unchanged but there were no suitable optimisations, instead make it an else to fall through to absolute addressing.
2009-10-12 16:41:02 +00:00
} else if (cx == thisx) {
/*
* Moving row only, column staying the same.
*/
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
/* One above. */
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
if (thisy != tty->rupper &&
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
cy == thisy - 1 && tty_term_has(term, TTYC_CUU1)) {
tty_putcode(tty, TTYC_CUU1);
goto out;
}
/* One below. */
When checking whether the region will scroll and the cursor position is thus unsuitable for using CUD/CUU, check the current cursor position not the target position.
2009-10-16 19:09:40 +00:00
if (thisy != tty->rlower &&
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
cy == thisy + 1 && tty_term_has(term, TTYC_CUD1)) {
tty_putcode(tty, TTYC_CUD1);
goto out;
}
/* Calculate difference. */
change = thisy - cy; /* +ve up, -ve down */
/*
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
* Try to use VPA if change is larger than absolute or if this
* change would cross the scroll region, otherwise use CUU/CUD.
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
*/
Shut up gcc4 warnings.
2010-06-05 16:32:22 +00:00
if ((u_int) abs(change) > cy ||
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
(change < 0 && cy - change > tty->rlower) ||
If the vertical cursor movement crosses the scroll region, CUU and CUD shouldn't be used even if VPA isn't present - in that case CUP should be used.
2009-10-12 16:37:43 +00:00
(change > 0 && cy - change < tty->rupper)) {
if (tty_term_has(term, TTYC_VPA)) {
tty_putcode1(tty, TTYC_VPA, cy);
goto out;
}
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
} else if (change > 0 && tty_term_has(term, TTYC_CUU)) {
tty_putcode1(tty, TTYC_CUU, change);
goto out;
} else if (change < 0 && tty_term_has(term, TTYC_CUD)) {
tty_putcode1(tty, TTYC_CUD, -change);
goto out;
}
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 relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
Use absolute movement if right at the end of the line as it isn't a reliable place to move from relatively.
2009-10-12 14:54:19 +00:00
absolute:
Use relative cursor movement instead of absolute when possible and when supported by the terminal to reduce the size of the output data (generally about 10-20%).
2009-10-12 13:01:18 +00:00
/* Absolute movement. */
tty_putcode2(tty, TTYC_CUP, cy, cx);
out:
tty->cx = cx;
tty->cy = cy;
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
}
void
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +00:00
tty_attributes(struct tty *tty, const struct grid_cell *gc,
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
const struct grid_cell *defaults, int *palette)
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
{
Add a minor optimisatin: if the character being printed is space, don't worry about setting the background colour or attributes (except reverse).
2009-10-28 08:52:36 +00:00
struct grid_cell *tc = &tty->cell, gc2;
Add support for the strikethrough attribute (SGR 9), using the new smxx terminfo capability. This means there are now nine attribute bits, so anything above 0xff uses an extended cell.
2017-03-22 07:16:54 +00:00
int changed;
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
Do not go through the whole attributes setting process if the new cell is the same as the previous one.
2017-02-06 19:45:23 +00:00
/* Copy cell and update default colours. */
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
memcpy(&gc2, gc, sizeof gc2);
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if (gc2.fg == 8)
gc2.fg = defaults->fg;
if (gc2.bg == 8)
gc2.bg = defaults->bg;
/* Ignore cell if it is the same as the last one. */
if (gc2.attr == tty->last_cell.attr &&
gc2.fg == tty->last_cell.fg &&
gc2.bg == tty->last_cell.bg &&
gc2.us == tty->last_cell.us)
return;
Add a minor optimisatin: if the character being printed is space, don't worry about setting the background colour or attributes (except reverse).
2009-10-28 08:52:36 +00:00
If colours are not supported by the terminal, try to emulate a coloured background by setting or clearing the reverse attribute. This makes a few applications which don't use the reverse attribute themselves a little happier, and allows the status, message and mode options to have default attributes and fg/bg options that work as expected when set as reverse.
2009-08-05 16:26:38 +00:00
/*
* If no setab, try to use the reverse attribute as a best-effort for a
* non-default background. This is a bit of a hack but it doesn't do
* any serious harm and makes a couple of applications happier.
*/
if (!tty_term_has(tty->term, TTYC_SETAB)) {
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
if (gc2.attr & GRID_ATTR_REVERSE) {
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
if (gc2.fg != 7 && !COLOUR_DEFAULT(gc2.fg))
Fix the reverse emulation when a terminal doesn't have setab to use the correct fg/bg (adjusted if spaces) and happen before attribute setting.
2009-11-04 13:34:26 +00:00
gc2.attr &= ~GRID_ATTR_REVERSE;
If colours are not supported by the terminal, try to emulate a coloured background by setting or clearing the reverse attribute. This makes a few applications which don't use the reverse attribute themselves a little happier, and allows the status, message and mode options to have default attributes and fg/bg options that work as expected when set as reverse.
2009-08-05 16:26:38 +00:00
} else {
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
if (gc2.bg != 0 && !COLOUR_DEFAULT(gc2.bg))
Fix the reverse emulation when a terminal doesn't have setab to use the correct fg/bg (adjusted if spaces) and happen before attribute setting.
2009-11-04 13:34:26 +00:00
gc2.attr |= GRID_ATTR_REVERSE;
If colours are not supported by the terminal, try to emulate a coloured background by setting or clearing the reverse attribute. This makes a few applications which don't use the reverse attribute themselves a little happier, and allows the status, message and mode options to have default attributes and fg/bg options that work as expected when set as reverse.
2009-08-05 16:26:38 +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
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
/* Fix up the colours if necessary. */
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_check_fg(tty, palette, &gc2);
tty_check_bg(tty, palette, &gc2);
tty_check_us(tty, palette, &gc2);
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
/*
* If any bits are being cleared or the underline colour is now default,
* reset everything.
*/
if ((tc->attr & ~gc2.attr) || (tc->us != gc2.us && gc2.us == 0))
Fix the reverse emulation when a terminal doesn't have setab to use the correct fg/bg (adjusted if spaces) and happen before attribute setting.
2009-11-04 13:34:26 +00:00
tty_reset(tty);
/*
* Set the colours. This may call tty_reset() (so it comes next) and
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
* may add to (NOT remove) the desired attributes.
Fix the reverse emulation when a terminal doesn't have setab to use the correct fg/bg (adjusted if spaces) and happen before attribute setting.
2009-11-04 13:34:26 +00:00
*/
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
tty_colours(tty, &gc2);
Fix the reverse emulation when a terminal doesn't have setab to use the correct fg/bg (adjusted if spaces) and happen before attribute setting.
2009-11-04 13:34:26 +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
/* Filter out attribute bits already set. */
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
changed = gc2.attr & ~tc->attr;
tc->attr = gc2.attr;
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
/* Set the attributes. */
if (changed & GRID_ATTR_BRIGHT)
tty_putcode(tty, TTYC_BOLD);
if (changed & GRID_ATTR_DIM)
tty_putcode(tty, TTYC_DIM);
If default-terminal is set to "screen" or "screen-*", emulate screen's historical (incorrect) behaviour for SGR 3 and send smso (standout). Previously, we would send sitm (italics) if the terminal outside had it and smso otherwise. This was acceptably until recently because xterm's terminfo entry lacked sitm, so most users got smso. People who want italics should set default-terminal to the forthcoming "tmux" entry (and be prepared to deal with it being missing on older hosts). As a side-effect this changes default-terminal to be a server rather than a session option. suggested by and ok naddy
2015-04-29 15:59:08 +00:00
if (changed & GRID_ATTR_ITALICS)
tty_set_italics(tty);
Support for extended underline styles on terminals which offer them, enabled by adding the Smulx capability with terminal-overrides (add something like ',vte*:Smulx=\E[4\:%p1%dm'). GitHub issue 1492.
2018-10-18 07:57:57 +00:00
if (changed & GRID_ATTR_ALL_UNDERSCORE) {
if ((changed & GRID_ATTR_UNDERSCORE) ||
!tty_term_has(tty->term, TTYC_SMULX))
tty_putcode(tty, TTYC_SMUL);
else if (changed & GRID_ATTR_UNDERSCORE_2)
tty_putcode1(tty, TTYC_SMULX, 2);
else if (changed & GRID_ATTR_UNDERSCORE_3)
tty_putcode1(tty, TTYC_SMULX, 3);
else if (changed & GRID_ATTR_UNDERSCORE_4)
tty_putcode1(tty, TTYC_SMULX, 4);
else if (changed & GRID_ATTR_UNDERSCORE_5)
tty_putcode1(tty, TTYC_SMULX, 5);
}
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
if (changed & GRID_ATTR_BLINK)
tty_putcode(tty, TTYC_BLINK);
if (changed & GRID_ATTR_REVERSE) {
if (tty_term_has(tty->term, TTYC_REV))
tty_putcode(tty, TTYC_REV);
else if (tty_term_has(tty->term, TTYC_SMSO))
tty_putcode(tty, TTYC_SMSO);
}
if (changed & GRID_ATTR_HIDDEN)
tty_putcode(tty, TTYC_INVIS);
Add support for the strikethrough attribute (SGR 9), using the new smxx terminfo capability. This means there are now nine attribute bits, so anything above 0xff uses an extended cell.
2017-03-22 07:16:54 +00:00
if (changed & GRID_ATTR_STRIKETHROUGH)
tty_putcode(tty, TTYC_SMXX);
Add support for overline (SGR 53), from Ricardo Banffy.
2019-05-13 20:10:23 +00:00
if (changed & GRID_ATTR_OVERLINE)
tty_putcode(tty, TTYC_SMOL);
Check the terminfo(5) U8 capability and disable using UTF-8 for ACS if it is present and zero. This is useful for users with terminals or fonts that do not correctly support UTF-8 line drawing characters. GitHub issue 927, reported by Hiroaki Yamazoe and Akinori Hattori.
2017-05-15 16:44:04 +00:00
if ((changed & GRID_ATTR_CHARSET) && tty_acs_needed(tty))
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
tty_putcode(tty, TTYC_SMACS);
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
memcpy(&tty->last_cell, &gc2, sizeof tty->last_cell);
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
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
tty_colours(struct tty *tty, const struct grid_cell *gc)
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
{
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
struct grid_cell *tc = &tty->cell;
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
int have_ax;
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
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
/* No changes? Nothing is necessary. */
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
if (gc->fg == tc->fg && gc->bg == tc->bg && gc->us == tc->us)
Add a minor optimisatin: if the character being printed is space, don't worry about setting the background colour or attributes (except reverse).
2009-10-28 08:52:36 +00:00
return;
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
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
/*
* Is either the default colour? This is handled specially because the
* best solution might be to reset both colours to default, in which
* case if only one is default need to fall onward to set the other
* colour.
*/
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
if (COLOUR_DEFAULT(gc->fg) || COLOUR_DEFAULT(gc->bg)) {
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
/*
* If don't have AX but do have op, send sgr0 (op can't
* actually be used because it is sometimes the same as sgr0
* and sometimes isn't). This resets both colours to default.
*
* Otherwise, try to set the default colour only as needed.
*/
Use tty_term_flag not _has for flags, also fix a typo (position not permission).
2015-04-15 22:10:13 +00:00
have_ax = tty_term_flag(tty->term, TTYC_AX);
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
if (!have_ax && tty_term_has(tty->term, TTYC_OP))
tty_reset(tty);
else {
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
if (COLOUR_DEFAULT(gc->fg) && !COLOUR_DEFAULT(tc->fg)) {
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
if (have_ax)
tty_puts(tty, "\033[39m");
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
else if (tc->fg != 7)
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
tty_putcode1(tty, TTYC_SETAF, 7);
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
tc->fg = gc->fg;
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
}
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
if (COLOUR_DEFAULT(gc->bg) && !COLOUR_DEFAULT(tc->bg)) {
Massive spaces->tabs and trailing whitespace cleanup, hopefully for the last time now I've configured emacs to make them displayed in really annoying colours...
2009-12-03 22:50:09 +00:00
if (have_ax)
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
tty_puts(tty, "\033[49m");
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
else if (tc->bg != 0)
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
tty_putcode1(tty, TTYC_SETAB, 0);
Should save the bg colour when setting it to default, not the fg.
2019-01-15 12:08:53 +00:00
tc->bg = gc->bg;
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +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
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
/* Set the foreground colour. */
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
if (!COLOUR_DEFAULT(gc->fg) && gc->fg != tc->fg)
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
tty_colours_fg(tty, gc);
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
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
/*
* Set the background colour. This must come after the foreground as
* tty_colour_fg() can call tty_reset().
*/
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
if (!COLOUR_DEFAULT(gc->bg) && gc->bg != tc->bg)
Remove a couple of unused arguments where possible, and add /* ARGSUSED */ to the rest to reduce lint output.
2009-11-26 21:37:13 +00:00
tty_colours_bg(tty, gc);
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
/* Set the underscore color. */
if (gc->us != tc->us)
tty_colours_us(tty, gc);
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
}
Add support for the OSC 4 and OSC 104 palette setting escape sequences, from S Gilles.
2017-01-07 15:28:13 +00:00
static void
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_check_fg(struct tty *tty, int *palette, struct grid_cell *gc)
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
{
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
u_char r, g, b;
u_int colours;
Fix setting the palette of aixterm colours (90-97).
2017-01-12 00:19:32 +00:00
int c;
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
Foreground colours with the bright attribute set need to use the bright entries in the palette. GitHub issue 954.
2017-06-03 07:15:23 +00:00
/*
* Perform substitution if this pane has a palette. If the bright
* attribute is set, use the bright entry in the palette by changing to
* the aixterm colour.
*/
if (~gc->flags & GRID_FLAG_NOPALETTE) {
c = gc->fg;
Typo/style; plus man page escaping from jmc.
2017-06-04 08:02:20 +00:00
if (c < 8 && gc->attr & GRID_ATTR_BRIGHT)
Foreground colours with the bright attribute set need to use the bright entries in the palette. GitHub issue 954.
2017-06-03 07:15:23 +00:00
c += 90;
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if ((c = tty_get_palette(palette, c)) != -1)
Foreground colours with the bright attribute set need to use the bright entries in the palette. GitHub issue 954.
2017-06-03 07:15:23 +00:00
gc->fg = c;
}
Add support for the OSC 4 and OSC 104 palette setting escape sequences, from S Gilles.
2017-01-07 15:28:13 +00:00
Support for RGB colour, using the extended cell mechanism to avoid wasting unnecessary space. The 'Tc' flag must be set in the external TERM entry (using terminal-overrides or a custom terminfo entry), if not tmux will map to the closest of the 256 or 16 colour palettes. Mostly from Suraj N Kurapati, based on a diff originally by someone else.
2016-01-29 11:13:56 +00:00
/* Is this a 24-bit colour? */
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (gc->fg & COLOUR_FLAG_RGB) {
Support for RGB colour, using the extended cell mechanism to avoid wasting unnecessary space. The 'Tc' flag must be set in the external TERM entry (using terminal-overrides or a custom terminfo entry), if not tmux will map to the closest of the 256 or 16 colour palettes. Mostly from Suraj N Kurapati, based on a diff originally by someone else.
2016-01-29 11:13:56 +00:00
/* Not a 24-bit terminal? Translate to 256-colour palette. */
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
if (tty->term->flags & TERM_RGBCOLOURS)
RGB colours shouldn't be mixed up with aixterm colours, return before that happens when working out if they are supported.
2016-03-03 12:58:15 +00:00
return;
If we can identify the terminal as iTerm2 or as tmux, we can be sure they support 256 and RGB colours, so set those flags too.
2020-01-28 11:39:51 +00:00
colour_split_rgb(gc->fg, &r, &g, &b);
gc->fg = colour_find_rgb(r, g, b);
Support for RGB colour, using the extended cell mechanism to avoid wasting unnecessary space. The 'Tc' flag must be set in the external TERM entry (using terminal-overrides or a custom terminfo entry), if not tmux will map to the closest of the 256 or 16 colour palettes. Mostly from Suraj N Kurapati, based on a diff originally by someone else.
2016-01-29 11:13:56 +00:00
}
aixterm colours can be used if -2 is given, as well as if TERM tells us the terminal has >=16 colours.
2017-01-12 00:30:41 +00:00
/* How many colours does this terminal have? */
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
if (tty->term->flags & TERM_256COLOURS)
aixterm colours can be used if -2 is given, as well as if TERM tells us the terminal has >=16 colours.
2017-01-12 00:30:41 +00:00
colours = 256;
else
colours = tty_term_number(tty->term, TTYC_COLORS);
Fix some issues in bright colour handling. Bold background doesn't exist so there is no reason for tty_check_bg to mess with the BRIGHT flag at all, ever. Also use aixterm colours for 256-to-16 translation if the terminal supports them. And there is no reason for tty_colours_bg to worry about whether the terminal supports them - tty_check_bg has already taken care of it.
2015-04-15 22:34:46 +00:00
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
/* Is this a 256-colour colour? */
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (gc->fg & COLOUR_FLAG_256) {
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
/* And not a 256 colour mode? */
Redraw any visible modes when status line changes so that formats like the pane title are updated. GitHub issue 2487. Also a man page fix from jmc.
2020-12-03 07:12:11 +00:00
if (colours < 256) {
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
gc->fg = colour_256to16(gc->fg);
if (gc->fg & 8) {
gc->fg &= 7;
Fix some issues in bright colour handling. Bold background doesn't exist so there is no reason for tty_check_bg to mess with the BRIGHT flag at all, ever. Also use aixterm colours for 256-to-16 translation if the terminal supports them. And there is no reason for tty_colours_bg to worry about whether the terminal supports them - tty_check_bg has already taken care of it.
2015-04-15 22:34:46 +00:00
if (colours >= 16)
gc->fg += 90;
Do not use bright when emulating 256 colours on an 8 colour terminal because it is also bold on some terminals. GitHub issue 1914.
2019-09-19 08:56:37 +00:00
}
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
}
return;
}
/* Is this an aixterm colour? */
if (gc->fg >= 90 && gc->fg <= 97 && colours < 16) {
gc->fg -= 90;
gc->attr |= GRID_ATTR_BRIGHT;
}
}
Add support for the OSC 4 and OSC 104 palette setting escape sequences, from S Gilles.
2017-01-07 15:28:13 +00:00
static void
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_check_bg(struct tty *tty, int *palette, struct grid_cell *gc)
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
{
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
u_char r, g, b;
u_int colours;
Fix setting the palette of aixterm colours (90-97).
2017-01-12 00:19:32 +00:00
int c;
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
Foreground colours with the bright attribute set need to use the bright entries in the palette. GitHub issue 954.
2017-06-03 07:15:23 +00:00
/* Perform substitution if this pane has a palette. */
if (~gc->flags & GRID_FLAG_NOPALETTE) {
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if ((c = tty_get_palette(palette, gc->bg)) != -1)
Foreground colours with the bright attribute set need to use the bright entries in the palette. GitHub issue 954.
2017-06-03 07:15:23 +00:00
gc->bg = c;
}
Add support for the OSC 4 and OSC 104 palette setting escape sequences, from S Gilles.
2017-01-07 15:28:13 +00:00
Support for RGB colour, using the extended cell mechanism to avoid wasting unnecessary space. The 'Tc' flag must be set in the external TERM entry (using terminal-overrides or a custom terminfo entry), if not tmux will map to the closest of the 256 or 16 colour palettes. Mostly from Suraj N Kurapati, based on a diff originally by someone else.
2016-01-29 11:13:56 +00:00
/* Is this a 24-bit colour? */
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (gc->bg & COLOUR_FLAG_RGB) {
Support for RGB colour, using the extended cell mechanism to avoid wasting unnecessary space. The 'Tc' flag must be set in the external TERM entry (using terminal-overrides or a custom terminfo entry), if not tmux will map to the closest of the 256 or 16 colour palettes. Mostly from Suraj N Kurapati, based on a diff originally by someone else.
2016-01-29 11:13:56 +00:00
/* Not a 24-bit terminal? Translate to 256-colour palette. */
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
if (tty->term->flags & TERM_RGBCOLOURS)
RGB colours shouldn't be mixed up with aixterm colours, return before that happens when working out if they are supported.
2016-03-03 12:58:15 +00:00
return;
If we can identify the terminal as iTerm2 or as tmux, we can be sure they support 256 and RGB colours, so set those flags too.
2020-01-28 11:39:51 +00:00
colour_split_rgb(gc->bg, &r, &g, &b);
gc->bg = colour_find_rgb(r, g, b);
Support for RGB colour, using the extended cell mechanism to avoid wasting unnecessary space. The 'Tc' flag must be set in the external TERM entry (using terminal-overrides or a custom terminfo entry), if not tmux will map to the closest of the 256 or 16 colour palettes. Mostly from Suraj N Kurapati, based on a diff originally by someone else.
2016-01-29 11:13:56 +00:00
}
aixterm colours can be used if -2 is given, as well as if TERM tells us the terminal has >=16 colours.
2017-01-12 00:30:41 +00:00
/* How many colours does this terminal have? */
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
if (tty->term->flags & TERM_256COLOURS)
aixterm colours can be used if -2 is given, as well as if TERM tells us the terminal has >=16 colours.
2017-01-12 00:30:41 +00:00
colours = 256;
else
colours = tty_term_number(tty->term, TTYC_COLORS);
Fix some issues in bright colour handling. Bold background doesn't exist so there is no reason for tty_check_bg to mess with the BRIGHT flag at all, ever. Also use aixterm colours for 256-to-16 translation if the terminal supports them. And there is no reason for tty_colours_bg to worry about whether the terminal supports them - tty_check_bg has already taken care of it.
2015-04-15 22:34:46 +00:00
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
/* Is this a 256-colour colour? */
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (gc->bg & COLOUR_FLAG_256) {
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
/*
* And not a 256 colour mode? Translate to 16-colour
* palette. Bold background doesn't exist portably, so just
* discard the bold bit if set.
*/
Redraw any visible modes when status line changes so that formats like the pane title are updated. GitHub issue 2487. Also a man page fix from jmc.
2020-12-03 07:12:11 +00:00
if (colours < 256) {
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
gc->bg = colour_256to16(gc->bg);
Fix some issues in bright colour handling. Bold background doesn't exist so there is no reason for tty_check_bg to mess with the BRIGHT flag at all, ever. Also use aixterm colours for 256-to-16 translation if the terminal supports them. And there is no reason for tty_colours_bg to worry about whether the terminal supports them - tty_check_bg has already taken care of it.
2015-04-15 22:34:46 +00:00
if (gc->bg & 8) {
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
gc->bg &= 7;
Fix some issues in bright colour handling. Bold background doesn't exist so there is no reason for tty_check_bg to mess with the BRIGHT flag at all, ever. Also use aixterm colours for 256-to-16 translation if the terminal supports them. And there is no reason for tty_colours_bg to worry about whether the terminal supports them - tty_check_bg has already taken care of it.
2015-04-15 22:34:46 +00:00
if (colours >= 16)
Use bg not fg when adjusting for aixterm, from Ailin Nemui.
2019-04-24 20:32:31 +00:00
gc->bg += 90;
Fix some issues in bright colour handling. Bold background doesn't exist so there is no reason for tty_check_bg to mess with the BRIGHT flag at all, ever. Also use aixterm colours for 256-to-16 translation if the terminal supports them. And there is no reason for tty_colours_bg to worry about whether the terminal supports them - tty_check_bg has already taken care of it.
2015-04-15 22:34:46 +00:00
}
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
}
return;
}
/* Is this an aixterm colour? */
Fix some issues in bright colour handling. Bold background doesn't exist so there is no reason for tty_check_bg to mess with the BRIGHT flag at all, ever. Also use aixterm colours for 256-to-16 translation if the terminal supports them. And there is no reason for tty_colours_bg to worry about whether the terminal supports them - tty_check_bg has already taken care of it.
2015-04-15 22:34:46 +00:00
if (gc->bg >= 90 && gc->bg <= 97 && colours < 16)
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
gc->bg -= 90;
}
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
static void
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_check_us(__unused struct tty *tty, int *palette, struct grid_cell *gc)
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
{
int c;
/* Perform substitution if this pane has a palette. */
if (~gc->flags & GRID_FLAG_NOPALETTE) {
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
if ((c = tty_get_palette(palette, gc->us)) != -1)
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
gc->us = c;
}
/* Underscore colour is set as RGB so convert a 256 colour to RGB. */
if (gc->us & COLOUR_FLAG_256)
gc->us = colour_256toRGB (gc->us);
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
tty_colours_fg(struct tty *tty, const struct grid_cell *gc)
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
{
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
struct grid_cell *tc = &tty->cell;
Pass through the aixterm bright colours if the terminal supports them (>= 16 colours).
2009-12-14 21:33:38 +00:00
char s[32];
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
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
/* Is this a 24-bit or 256-colour colour? */
Handle terminfo colors > 256 correctly, GitHub issue 1337.
2018-05-07 13:39:09 +00:00
if (gc->fg & COLOUR_FLAG_RGB || gc->fg & COLOUR_FLAG_256) {
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (tty_try_colour(tty, gc->fg, "38") == 0)
Use the setal capability as well as (tmux's) Setulc.
2020-10-05 09:53:01 +00:00
goto save;
Support for RGB colour, using the extended cell mechanism to avoid wasting unnecessary space. The 'Tc' flag must be set in the external TERM entry (using terminal-overrides or a custom terminfo entry), if not tmux will map to the closest of the 256 or 16 colour palettes. Mostly from Suraj N Kurapati, based on a diff originally by someone else.
2016-01-29 11:13:56 +00:00
/* Should not get here, already converted in tty_check_fg. */
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
return;
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
}
Pass through the aixterm bright colours if the terminal supports them (>= 16 colours).
2009-12-14 21:33:38 +00:00
/* Is this an aixterm bright colour? */
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (gc->fg >= 90 && gc->fg <= 97) {
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
if (tty->term->flags & TERM_256COLOURS) {
Need a fallback for -2 for aixterm colours.
2019-04-25 19:03:43 +00:00
xsnprintf(s, sizeof s, "\033[%dm", gc->fg);
tty_puts(tty, s);
} else
tty_putcode1(tty, TTYC_SETAF, gc->fg - 90 + 8);
Use the setal capability as well as (tmux's) Setulc.
2020-10-05 09:53:01 +00:00
goto save;
Pass through the aixterm bright colours if the terminal supports them (>= 16 colours).
2009-12-14 21:33:38 +00:00
}
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
/* Otherwise set the foreground colour. */
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
tty_putcode1(tty, TTYC_SETAF, gc->fg);
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
Use the setal capability as well as (tmux's) Setulc.
2020-10-05 09:53:01 +00:00
save:
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
/* Save the new values in the terminal current cell. */
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
tc->fg = gc->fg;
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
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Remove a couple of unused arguments where possible, and add /* ARGSUSED */ to the rest to reduce lint output.
2009-11-26 21:37:13 +00:00
tty_colours_bg(struct tty *tty, const struct grid_cell *gc)
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
{
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
struct grid_cell *tc = &tty->cell;
Pass through the aixterm bright colours if the terminal supports them (>= 16 colours).
2009-12-14 21:33:38 +00:00
char s[32];
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
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
/* Is this a 24-bit or 256-colour colour? */
Handle terminfo colors > 256 correctly, GitHub issue 1337.
2018-05-07 13:39:09 +00:00
if (gc->bg & COLOUR_FLAG_RGB || gc->bg & COLOUR_FLAG_256) {
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (tty_try_colour(tty, gc->bg, "48") == 0)
Use the setal capability as well as (tmux's) Setulc.
2020-10-05 09:53:01 +00:00
goto save;
Support for RGB colour, using the extended cell mechanism to avoid wasting unnecessary space. The 'Tc' flag must be set in the external TERM entry (using terminal-overrides or a custom terminfo entry), if not tmux will map to the closest of the 256 or 16 colour palettes. Mostly from Suraj N Kurapati, based on a diff originally by someone else.
2016-01-29 11:13:56 +00:00
/* Should not get here, already converted in tty_check_bg. */
Check for colour and attribute modifications early so the translated values can be stored in the cached terminal attributes rather than the requested (untranslated) values. Prevents tmux clearing and setting the attributes for every character when using aixterm colours.
2010-03-01 22:44:31 +00:00
return;
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
}
Pass through the aixterm bright colours if the terminal supports them (>= 16 colours).
2009-12-14 21:33:38 +00:00
/* Is this an aixterm bright colour? */
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (gc->bg >= 90 && gc->bg <= 97) {
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
if (tty->term->flags & TERM_256COLOURS) {
Need a fallback for -2 for aixterm colours.
2019-04-25 19:03:43 +00:00
xsnprintf(s, sizeof s, "\033[%dm", gc->bg + 10);
tty_puts(tty, s);
} else
tty_putcode1(tty, TTYC_SETAB, gc->bg - 90 + 8);
Use the setal capability as well as (tmux's) Setulc.
2020-10-05 09:53:01 +00:00
goto save;
Pass through the aixterm bright colours if the terminal supports them (>= 16 colours).
2009-12-14 21:33:38 +00:00
}
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
/* Otherwise set the background colour. */
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
tty_putcode1(tty, TTYC_SETAB, gc->bg);
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
Use the setal capability as well as (tmux's) Setulc.
2020-10-05 09:53:01 +00:00
save:
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
/* Save the new values in the terminal current cell. */
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
tc->bg = gc->bg;
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
}
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
static void
tty_colours_us(struct tty *tty, const struct grid_cell *gc)
{
struct grid_cell *tc = &tty->cell;
u_int c;
u_char r, g, b;
Use the setal capability as well as (tmux's) Setulc.
2020-10-05 09:53:01 +00:00
/* Clear underline colour. */
if (gc->us == 0) {
tty_putcode(tty, TTYC_OL);
goto save;
}
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
/* Must be an RGB colour - this should never happen. */
if (~gc->us & COLOUR_FLAG_RGB)
return;
/*
Use the setal capability as well as (tmux's) Setulc.
2020-10-05 09:53:01 +00:00
* Setulc and setal follows the ncurses(3) one argument "direct colour"
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
* capability format. Calculate the colour value.
*/
colour_split_rgb(gc->us, &r, &g, &b);
c = (65536 * r) + (256 * g) + b;
Use the setal capability as well as (tmux's) Setulc.
2020-10-05 09:53:01 +00:00
/*
* Write the colour. Only use setal if the RGB flag is set because the
* non-RGB version may be wrong.
*/
if (tty_term_has(tty->term, TTYC_SETULC))
tty_putcode1(tty, TTYC_SETULC, c);
else if (tty_term_has(tty->term, TTYC_SETAL) &&
tty_term_has(tty->term, TTYC_RGB))
tty_putcode1(tty, TTYC_SETAL, c);
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
Use the setal capability as well as (tmux's) Setulc.
2020-10-05 09:53:01 +00:00
save:
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
/* Save the new values in the terminal current cell. */
tc->us = gc->us;
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
tty_try_colour(struct tty *tty, int colour, const char *type)
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
{
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
u_char r, g, b;
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (colour & COLOUR_FLAG_256) {
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
if (*type == '3' && tty_term_has(tty->term, TTYC_SETAF))
tty_putcode1(tty, TTYC_SETAF, colour & 0xff);
else if (tty_term_has(tty->term, TTYC_SETAB))
tty_putcode1(tty, TTYC_SETAB, colour & 0xff);
return (0);
If the terminfo entry has colors#256, assume that setaf and setab work and use them for the 256 colour set. If the terminfo entry doesn't have colors#256 and the user gives -2 to the client, use a \033[38;5;Xm sequence as before. Should allow fbterm to work with it's weird setaf and setab.
2014-02-14 14:37:08 +00:00
}
Setting SGR0 when setting the fg and bg has problems if only one of the two is meant to be default, so rewrite the code to move this outside, move setting colours before attributes and generally clean up. Tested by sthen@, fixes problems he was seeing with mutt and should fix some existing problems with (rarely) lost attributes.
2009-10-28 08:27:33 +00:00
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (colour & COLOUR_FLAG_RGB) {
If we can identify the terminal as iTerm2 or as tmux, we can be sure they support 256 and RGB colours, so set those flags too.
2020-01-28 11:39:51 +00:00
colour_split_rgb(colour & 0xffffff, &r, &g, &b);
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
if (*type == '3' && tty_term_has(tty->term, TTYC_SETRGBF))
Look for setrgbf and setrgbb terminfo extensions for RGB colour. This is the most reasonable of the various (some bizarre) suggestions for capabilities.
2017-05-31 08:43:44 +00:00
tty_putcode3(tty, TTYC_SETRGBF, r, g, b);
Tidy up the terminal detection and feature code and add named sets of terminal features, each of which are defined in one place and map to a builtin set of terminfo(5) capabilities. Features can be specified based on TERM with a new terminal-features option or with the -T flag when running tmux. tmux will also detect a few common terminals from the DA and DSR responses. This is intended to make it easier to configure tmux's use of terminfo(5) even in the presence of outdated ncurses(3) or terminfo(5) databases or for features which do not yet have a terminfo(5) entry. Instead of having to grok terminfo(5) capability names and what they should be set to in the terminal-overrides option, the user can hopefully just give tmux a feature name and let it do the right thing. The terminal-overrides option remains both for backwards compatibility and to allow tweaks of individual capabilities. tmux already did much of this already, this makes it tidier and simpler to configure.
2020-04-20 13:25:36 +00:00
else if (tty_term_has(tty->term, TTYC_SETRGBB))
Look for setrgbf and setrgbb terminfo extensions for RGB colour. This is the most reasonable of the various (some bizarre) suggestions for capabilities.
2017-05-31 08:43:44 +00:00
tty_putcode3(tty, TTYC_SETRGBB, r, g, b);
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
return (0);
}
Support for RGB colour, using the extended cell mechanism to avoid wasting unnecessary space. The 'Tc' flag must be set in the external TERM entry (using terminal-overrides or a custom terminfo entry), if not tmux will map to the closest of the 256 or 16 colour palettes. Mostly from Suraj N Kurapati, based on a diff originally by someone else.
2016-01-29 11:13:56 +00:00
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
return (-1);
Support for RGB colour, using the extended cell mechanism to avoid wasting unnecessary space. The 'Tc' flag must be set in the external TERM entry (using terminal-overrides or a custom terminfo entry), if not tmux will map to the closest of the 256 or 16 colour palettes. Mostly from Suraj N Kurapati, based on a diff originally by someone else.
2016-01-29 11:13:56 +00:00
}
Drop having a separate type for style options and make them all strings, which allows formats to be expanded. Any styles without a '#{' are still validated when they are set but any with a '#{' are not. Formats are not expanded usefully in many cases yet, that will be changed later. To make this work, a few other changes: - set-option -a with a style option automatically appends a ",". - OSC 10 and 11 don't set the window-style option anymore, instead the fg and bg are stored in the pane struct and act as the defaults that can be overridden by window-style. - status-fg and -bg now override status-style instead of trying to keep them in sync.
2020-05-16 15:01:30 +00:00
static void
tty_window_default_style(struct grid_cell *gc, struct window_pane *wp)
{
memcpy(gc, &grid_default_cell, sizeof *gc);
gc->fg = wp->fg;
gc->bg = wp->bg;
}
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
void
Add a wrapper (struct style) around styles rather than using the grid_cell directly. There will be some non-cell members soon.
2019-03-14 09:53:52 +00:00
tty_default_colours(struct grid_cell *gc, struct window_pane *wp)
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +00:00
{
Add a per-pane option set. Pane options inherit from window options (so there should be no change to existing behaviour) and are set and shown with set-option -p and show-options -p. Change remain-on-exit and window-style/window-active-style to be pane options (some others will be changed later). This makes select-pane -P and -g unnecessary so no longer document them (they still work) and no longer document set-window-option and show-window-options in favour of set-option -w and show-options -w.
2019-06-20 11:59:59 +00:00
struct options *oo = wp->options;
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
memcpy(gc, &grid_default_cell, sizeof *gc);
Add a per-pane option set. Pane options inherit from window options (so there should be no change to existing behaviour) and are set and shown with set-option -p and show-options -p. Change remain-on-exit and window-style/window-active-style to be pane options (some others will be changed later). This makes select-pane -P and -g unnecessary so no longer document them (they still work) and no longer document set-window-option and show-window-options in favour of set-option -w and show-options -w.
2019-06-20 11:59:59 +00:00
if (wp->flags & PANE_STYLECHANGED) {
wp->flags &= ~PANE_STYLECHANGED;
Drop having a separate type for style options and make them all strings, which allows formats to be expanded. Any styles without a '#{' are still validated when they are set but any with a '#{' are not. Formats are not expanded usefully in many cases yet, that will be changed later. To make this work, a few other changes: - set-option -a with a style option automatically appends a ",". - OSC 10 and 11 don't set the window-style option anymore, instead the fg and bg are stored in the pane struct and act as the defaults that can be overridden by window-style. - status-fg and -bg now override status-style instead of trying to keep them in sync.
2020-05-16 15:01:30 +00:00
tty_window_default_style(&wp->cached_active_gc, wp);
style_add(&wp->cached_active_gc, oo, "window-active-style",
NULL);
tty_window_default_style(&wp->cached_gc, wp);
style_add(&wp->cached_gc, oo, "window-style", NULL);
Cache the window styles and do not look up the window-style options unless they have changed.
2016-05-30 09:50:20 +00:00
}
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +00:00
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (gc->fg == 8) {
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
if (wp == wp->window->active && wp->cached_active_gc.fg != 8)
gc->fg = wp->cached_active_gc.fg;
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
else
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
gc->fg = wp->cached_gc.fg;
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +00:00
}
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
if (gc->bg == 8) {
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
if (wp == wp->window->active && wp->cached_active_gc.bg != 8)
gc->bg = wp->cached_active_gc.bg;
Don't update cells in each block of data read from a pane immediately, instead track them as change (dirty) and update them once at the end, saves much time if repeatedly writing the same cell. Also fix comparison of cells being equal in a few places (memcmp is not enough).
2016-07-15 00:49:08 +00:00
else
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
gc->bg = wp->cached_gc.bg;
Support setting the default window and pane background colours (window and active pane via window-style and window-active-style options, an individual pane by a new select-pane -P flag). From J Raynor.
2015-04-19 21:05:27 +00:00
}
}
Add support for BCE (background colour erase). This makes various escape sequences (notable EL and ED but also IL, DL, ICH, DCH) create blank cells using the current background colour rather than the default colour. On modern systems BCE doesn't really have many benefits, but most other terminals now support it, some (lazy) applications rely on it, and it is not hard to include now that we have pane background colours anyway. Mostly written by Sean Haugh.
2016-10-13 20:27:27 +00:00
static void
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_default_attributes(struct tty *tty, const struct grid_cell *defaults,
int *palette, u_int bg)
Add support for BCE (background colour erase). This makes various escape sequences (notable EL and ED but also IL, DL, ICH, DCH) create blank cells using the current background colour rather than the default colour. On modern systems BCE doesn't really have many benefits, but most other terminals now support it, some (lazy) applications rely on it, and it is not hard to include now that we have pane background colours anyway. Mostly written by Sean Haugh.
2016-10-13 20:27:27 +00:00
{
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
struct grid_cell gc;
Add support for BCE (background colour erase). This makes various escape sequences (notable EL and ED but also IL, DL, ICH, DCH) create blank cells using the current background colour rather than the default colour. On modern systems BCE doesn't really have many benefits, but most other terminals now support it, some (lazy) applications rely on it, and it is not hard to include now that we have pane background colours anyway. Mostly written by Sean Haugh.
2016-10-13 20:27:27 +00:00
memcpy(&gc, &grid_default_cell, sizeof gc);
gc.bg = bg;
Do not hoke into struct window_pane from the tty code and instead set everything up in tty_ctx. Provide a way to initialize the tty_ctx from a callback and use it to let popups draw directly through input_parse in the same way as panes do, rather than forcing a full redraw on every change.
2020-05-16 15:34:08 +00:00
tty_attributes(tty, &gc, defaults, palette);
Add support for BCE (background colour erase). This makes various escape sequences (notable EL and ED but also IL, DL, ICH, DCH) create blank cells using the current background colour rather than the default colour. On modern systems BCE doesn't really have many benefits, but most other terminals now support it, some (lazy) applications rely on it, and it is not hard to include now that we have pane background colours anyway. Mostly written by Sean Haugh.
2016-10-13 20:27:27 +00:00
}
Reference in New Issue Copy Permalink