circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2024-12-25 02:48:47 +00:00
Code Issues Projects Releases Wiki Activity
da5d563375
tmux/tty.c

2509 lines
59 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
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static int tty_client_ready(struct client *, struct window_pane *);
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 *);
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 tty_check_fg(struct tty *, const struct window_pane *,
struct grid_cell *);
static void tty_check_bg(struct tty *, const struct window_pane *,
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 *);
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 *);
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 int tty_fake_bce(const struct tty *, const struct window_pane *,
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
static void tty_draw_pane(struct tty *, const struct tty_ctx *, u_int);
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void tty_cell(struct tty *, const struct grid_cell *,
const struct window_pane *);
static void tty_default_colours(struct grid_cell *,
const struct window_pane *);
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 tty_default_attributes(struct tty *, const struct window_pane *,
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) \
Revert use of DECSLRM on iTerm2, it doesn't help as much as we throught, and there are some question marks about it's support.
2017-04-18 21:41:42 +00:00
((tty)->term_type == TTY_VT420)
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
Detect iTerm2 and use DECSLRM for it as well.
2017-04-18 18:21:37 +00:00
#define tty_pane_full_width(tty, ctx) \
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
((ctx)->xoff == 0 && screen_size_x((ctx)->wp->screen) >= (tty)->sx)
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
Store client in tty struct directly instead of using a callback function pointer.
2012-05-22 14:32:28 +00:00
tty_init(struct tty *tty, struct client *c, int fd, char *term)
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 line endings.
2015-07-13 15:51:31 +00:00
if (!isatty(fd))
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);
Have the client pass its stdin fd to the server when identifying itself and have the server use that rather than reopening the tty. If the fd isn't given, use the old behaviour (so no need for a version change). This allows tmux to be used as the shell, so also change so that when working out the command to execute if default-command is empty (the default), tmux will try not execute itself.
2009-08-11 21:28:11 +00:00
Handle empty or unset TERM correctly; also fix a fatal() message while here.
2009-07-07 17:24:32 +00:00
if (term == NULL || *term == '\0')
Add a format for terminal type.
2017-01-11 16:09:57 +00:00
tty->term_name = xstrdup("unknown");
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
Add a format for terminal type.
2017-01-11 16:09:57 +00:00
tty->term_name = xstrdup(term);
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
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
tty->fd = fd;
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
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->flags = 0;
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
tty->term_flags = 0;
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->term_type = TTY_UNKNOWN;
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;
u_int sx, sy;
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
if (ioctl(tty->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;
if (sx == 0)
sx = 80;
sy = ws.ws_row;
if (sy == 0)
sy = 24;
} else {
sx = 80;
sy = 24;
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
}
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: %s now %ux%u", __func__, c->name, sx, sy);
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
tty_set_size(tty, sx, sy);
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
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_set_size(struct tty *tty, u_int sx, u_int sy)
{
Add a wrapper function tty_set_size from George Nachman.
2012-02-15 17:25:02 +00:00
tty->sx = sx;
tty->sy = sy;
}
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;
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;
nread = evbuffer_read(tty->in, tty->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) {
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
}
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: read %d bytes (already %zu)", c->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;
nwrite = evbuffer_write(tty->out, tty->fd);
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
{
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->term = tty_term_find(tty->term_name, tty->fd, cause);
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
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_set(&tty->event_in, tty->fd, EV_PERSIST|EV_READ,
tty_read_callback, tty);
tty->in = evbuffer_new();
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
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_set(&tty->event_out, tty->fd, EV_WRITE, tty_write_callback, tty);
tty->out = evbuffer_new();
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
}
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;
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->fd != -1 && tcgetattr(tty->fd, &tty->tio) == 0) {
setblocking(tty->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(tty->fd, TCSANOW, &tio) == 0)
tcflush(tty->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);
if (tty_term_has(tty->term, TTYC_KMOUS))
Explicitly cancel mouse "button" mode, this happens implicitly with some one of the other things we send with xterm, but not with urxvt. Reported by sthen@.
2015-04-25 15:57:48 +00:00
tty_puts(tty, "\033[?1000l\033[?1002l\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
Use tty_term_flag not _has for XT, and make -2 force direct use of 256-colour escape sequences (so setaf/setab can be bypassed if needed).
2015-10-23 15:52:54 +00:00
if (tty_term_flag(tty->term, TTYC_XT)) {
Move struct options into options.c.
2015-10-27 15:58:42 +00:00
if (options_get_number(global_options, "focus-events")) {
Focus events can cause trouble if left on and they can't be turned off during idle periods (like the other states are) because we'd miss events. So add a server option to control them. Defaults to off.
2013-06-23 13:10:46 +00:00
tty->flags |= TTY_FOCUS;
tty_puts(tty, "\033[?1004h");
}
Revert use of DECSLRM on iTerm2, it doesn't help as much as we throught, and there are some question marks about it's support.
2017-04-18 21:41:42 +00:00
tty_puts(tty, "\033[c");
Focus events can cause trouble if left on and they can't be turned off during idle periods (like the other states are) because we'd miss events. So add a server option to control them. Defaults to off.
2013-06-23 13:10:46 +00:00
}
Send secondary DA to terminals with XT in terminfo when starting up and parse it to work out the xterm version.
2012-03-15 10:36:00 +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->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
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
}
void
tty_stop_tty(struct tty *tty)
{
struct winsize ws;
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;
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.
*/
if (ioctl(tty->fd, TIOCGWINSZ, &ws) == -1)
return;
if (tcsetattr(tty->fd, TCSANOW, &tty->tio) == -1)
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)
tty_raw(tty, "\033[?2004l");
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_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));
if (tty_term_has(tty->term, TTYC_KMOUS))
Explicitly cancel mouse "button" mode, this happens implicitly with some one of the other things we send with xterm, but not with urxvt. Reported by sthen@.
2015-04-25 15:57:48 +00:00
tty_raw(tty, "\033[?1000l\033[?1002l\033[?1006l\033[?1005l");
Correctly handle UTF8 mouse option being toggled, from Egmont Koblinger.
2013-03-22 10:34:46 +00:00
Use tty_term_flag not _has for XT, and make -2 force direct use of 256-colour escape sequences (so setaf/setab can be bypassed if needed).
2015-10-23 15:52:54 +00:00
if (tty_term_flag(tty->term, TTYC_XT)) {
Focus events can cause trouble if left on and they can't be turned off during idle periods (like the other states are) because we'd miss events. So add a server option to control them. Defaults to off.
2013-06-23 13:10:46 +00:00
if (tty->flags & TTY_FOCUS) {
tty->flags &= ~TTY_FOCUS;
Focus off needs to be sent with tty_raw, reported by Geoff Nixon.
2015-01-30 12:33:03 +00:00
tty_raw(tty, "\033[?1004l");
Focus events can cause trouble if left on and they can't be turned off during idle periods (like the other states are) because we'd miss events. So add a server option to control them. Defaults to off.
2013-06-23 13:10:46 +00:00
}
}
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))
tty_raw(tty, "\033[?69l"); /* DECLRMM */
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
setblocking(tty->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
Add a TTY_OPENED flag and tidy a little.
2009-08-11 20:29:04 +00:00
if (tty->fd != -1) {
close(tty->fd);
tty->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_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);
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
xfree is not particularly helpful, remove it. From Thomas Adam.
2012-07-10 11:53:01 +00:00
free(tty->ccolour);
Add a format for terminal type.
2017-01-11 16:09:57 +00:00
free(tty->term_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
}
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
tty_set_type(struct tty *tty, int type)
{
tty->term_type = type;
if (tty_use_margin(tty))
tty_puts(tty, "\033[?69h"); /* DECLRMM */
}
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)
{
Correctly handle UTF8 mouse option being toggled, from Egmont Koblinger.
2013-03-22 10:34:46 +00:00
ssize_t n, slen;
u_int i;
slen = strlen(s);
for (i = 0; i < 5; i++) {
n = write(tty->fd, s, slen);
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
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
/*
* On !xenl 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.
*/
if (tty->term->flags & TERM_EARLYWRAP)
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
{
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
{
int changed;
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;
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)) {
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
if (s->cstyle == 0 &&
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_term_has(tty->term, TTYC_SE))
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;
}
Remove support for the UTF-8 mouse extension. This was a briefly used, poor idea that was fairly quickly replaced by SGR mouse input (which is now widespread). It is impossible to tell the difference between UTF-8 and non-UTF-8 mouse input; since the mouse-utf8 option was removed tmux has not handled it correctly in any case; and it is ridiculous to have three different forms of mouse input.
2015-11-23 20:53:09 +00:00
if (changed & ALL_MOUSE_MODES) {
Support all four of the xterm mouse modes. Based on a diff from hsim at gmx.li.
2010-12-29 21:49:06 +00:00
if (mode & ALL_MOUSE_MODES) {
Correctly handle UTF8 mouse option being toggled, from Egmont Koblinger.
2013-03-22 10:34:46 +00:00
/*
* Enable the SGR (1006) extension unconditionally, as
Add some missing special keys to key_string_lookup_key, fix a mouse check in server_client_handle_key, and tweak a comment.
2017-01-11 22:36:07 +00:00
* it is safe from misinterpretation.
Correctly handle UTF8 mouse option being toggled, from Egmont Koblinger.
2013-03-22 10:34:46 +00:00
*/
tty_puts(tty, "\033[?1006h");
Implement "all event" (1003) mouse mode but in a way that works. The main issue is that if we have two panes, A with 1002 and B with 1003, we need to set 1003 outside tmux in order to get all the mouse events, but then we need to suppress the ones that pane A doesn't want. This is easy in SGR mouse mode, because buttons == 3 is only used for movement events (for other events the trailing m/M marks a release instead), but in normal mouse mode we can't tell so easily. So for that, look at the previous event instead - if it is drag+release as well, then the current event is a movement event.
2017-02-01 09:55:07 +00:00
if (mode & MODE_MOUSE_ALL)
tty_puts(tty, "\033[?1003h");
else if (mode & MODE_MOUSE_BUTTON)
Support all four of the xterm mouse modes. Based on a diff from hsim at gmx.li.
2010-12-29 21:49:06 +00:00
tty_puts(tty, "\033[?1002h");
Only set a mouse mode for mouse-select-pane if none already set by the mode (any will do).
2011-01-15 00:46:19 +00:00
else if (mode & MODE_MOUSE_STANDARD)
tty_puts(tty, "\033[?1000h");
When the mode-mouse option is on, support dragging to make a selection in copy mode. Also support the scroll wheel, although xterm strangely does not ignore it in application mouse mode, causing redraw artifacts when scrolling up (other terminals appear to be better behaved).
2010-05-31 19:51:29 +00:00
} else {
Implement "all event" (1003) mouse mode but in a way that works. The main issue is that if we have two panes, A with 1002 and B with 1003, we need to set 1003 outside tmux in order to get all the mouse events, but then we need to suppress the ones that pane A doesn't want. This is easy in SGR mouse mode, because buttons == 3 is only used for movement events (for other events the trailing m/M marks a release instead), but in normal mouse mode we can't tell so easily. So for that, look at the previous event instead - if it is drag+release as well, then the current event is a movement event.
2017-02-01 09:55:07 +00:00
if (tty->mode & MODE_MOUSE_ALL)
tty_puts(tty, "\033[?1003l");
else if (tty->mode & MODE_MOUSE_BUTTON)
Support all four of the xterm mouse modes. Based on a diff from hsim at gmx.li.
2010-12-29 21:49:06 +00:00
tty_puts(tty, "\033[?1002l");
Only set a mouse mode for mouse-select-pane if none already set by the mode (any will do).
2011-01-15 00:46:19 +00:00
else if (tty->mode & MODE_MOUSE_STANDARD)
tty_puts(tty, "\033[?1000l");
Correctly handle UTF8 mouse option being toggled, from Egmont Koblinger.
2013-03-22 10:34:46 +00:00
tty_puts(tty, "\033[?1006l");
When the mode-mouse option is on, support dragging to make a selection in copy mode. Also support the scroll wheel, although xterm strangely does not ignore it in application mouse mode, causing redraw artifacts when scrolling up (other terminals appear to be better behaved).
2010-05-31 19:51:29 +00:00
}
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
}
Support "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)
tty_puts(tty, "\033[?2004h");
else
tty_puts(tty, "\033[?2004l");
}
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
/* Is this window bigger than the terminal? */
int
tty_window_bigger(struct tty *tty)
{
Only screen-redraw.c needs to adjust for message or prompt when the status line is off, get rid of tty_status_lines and just pass the client into status_line_size so it can check the CLIENT_STATUSOFF flag as well.
2018-08-20 19:05:34 +00:00
struct client *c = tty->client;
struct session *s = c->session;
struct window *w = s->curw->window;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
Only screen-redraw.c needs to adjust for message or prompt when the status line is off, get rid of tty_status_lines and just pass the client into status_line_size so it can check the CLIENT_STATUSOFF flag as well.
2018-08-20 19:05:34 +00:00
return (tty->sx < w->sx || tty->sy - status_line_size(c) < w->sy);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
}
/* 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)
{
Only screen-redraw.c needs to adjust for message or prompt when the status line is off, get rid of tty_status_lines and just pass the client into status_line_size so it can check the CLIENT_STATUSOFF flag as well.
2018-08-20 19:05:34 +00:00
struct client *c = tty->client;
struct window *w = c->session->curw->window;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
struct window_pane *wp = w->active;
u_int cx, cy, lines;
Only screen-redraw.c needs to adjust for message or prompt when the status line is off, get rid of tty_status_lines and just pass the client into status_line_size so it can check the CLIENT_STATUSOFF flag as well.
2018-08-20 19:05:34 +00:00
lines = status_line_size(c);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (tty->sx >= w->sx && tty->sy - lines >= w->sy) {
*ox = 0;
*oy = 0;
*sx = w->sx;
*sy = w->sy;
Add flags to refresh-client (-U -D -L -R and -c) to pan a window that is larger than the client manually. Bound to S-Up, S-Down, S-Left, S-Right and Delete manually. Also add aliases for keys DC = Delete, IC = Insert, and make refresh-client -C accept XxY as well as X,Y to match default-size.
2018-08-21 08:27:19 +00:00
c->pan_window = NULL;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
return (0);
}
*sx = tty->sx;
*sy = tty->sy - lines;
Add flags to refresh-client (-U -D -L -R and -c) to pan a window that is larger than the client manually. Bound to S-Up, S-Down, S-Left, S-Right and Delete manually. Also add aliases for keys DC = Delete, IC = Insert, and make refresh-client -C accept XxY as well as X,Y to match default-size.
2018-08-21 08:27:19 +00:00
if (c->pan_window == w) {
if (c->pan_ox + *sx > w->sx)
c->pan_ox = w->sx - *sx;
*ox = c->pan_ox;
if (c->pan_oy + *sy > w->sy)
c->pan_oy = w->sy - *sy;
*oy = c->pan_oy;
return (1);
}
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
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;
}
Add flags to refresh-client (-U -D -L -R and -c) to pan a window that is larger than the client manually. Bound to S-Up, S-Down, S-Left, S-Right and Delete manually. Also add aliases for keys DC = Delete, IC = Insert, and make refresh-client -C accept XxY as well as X,Y to match default-size.
2018-08-21 08:27:19 +00:00
c->pan_window = NULL;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
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;
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;
}
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
{
struct window_pane *wp = ctx->wp;
return (ctx->orlower - ctx->orupper >= screen_size_y(wp->screen) / 2);
}
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
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_fake_bce(const struct tty *tty, const struct window_pane *wp, 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
{
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
if (tty_term_flag(tty->term, TTYC_BCE))
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
memcpy(&gc, &grid_default_cell, sizeof gc);
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
if (wp != NULL)
tty_default_colours(&gc, 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 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 (bg != 8 || gc.bg != 8)
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
{
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
struct window_pane *wp = ctx->wp;
struct screen *s = wp->screen;
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
/*
Add a helper function for enabling an optimization to make some code clearer.
2012-03-15 09:10:33 +00:00
* If region is large, schedule a window 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)) {
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
wp->flags |= PANE_REDRAW;
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) {
for (i = ctx->ocy; i < screen_size_y(s); i++)
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
tty_draw_pane(tty, ctx, i);
}
}
/* Is this position visible in the pane? */
static int
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
tty_is_visible(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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
{
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
u_int xoff = ctx->xoff + px, yoff = ctx->yoff + py, lines;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (!ctx->bigger)
return (1);
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
if (status_at_line(tty->client) == 0)
Only screen-redraw.c needs to adjust for message or prompt when the status line is off, get rid of tty_status_lines and just pass the client into status_line_size so it can check the CLIENT_STATUSOFF flag as well.
2018-08-20 19:05:34 +00:00
lines = status_line_size(tty->client);
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
else
lines = 0;
Only screen-redraw.c needs to adjust for message or prompt when the status line is off, get rid of tty_status_lines and just pass the client into status_line_size so it can check the CLIENT_STATUSOFF flag as well.
2018-08-20 19:05:34 +00:00
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
if (xoff + nx <= ctx->ox || xoff >= ctx->ox + ctx->sx ||
yoff + ny <= ctx->oy || yoff >= lines + ctx->oy + ctx->sy) {
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
return (0);
}
return (1);
}
/* Clamp line position to visible part of pane. */
static int
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
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)
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
{
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
u_int xoff = ctx->xoff + px;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
if (!tty_is_visible(tty, ctx, px, py, nx, 1))
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
return (0);
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
*ry = ctx->yoff + py - ctx->oy;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (xoff >= ctx->ox && xoff + nx <= ctx->ox + ctx->sx) {
/* All visible. */
*i = 0;
*x = xoff - ctx->ox;
*rx = nx;
} else if (xoff < ctx->ox && xoff + nx > ctx->ox + ctx->sx) {
/* Both left and right not visible. */
*i = ctx->ox;
*x = 0;
*rx = ctx->sx;
} else if (xoff < ctx->ox) {
/* Left not visible. */
*i = ctx->ox - xoff;
*x = 0;
*rx = nx - *i;
} else {
/* Right not visible. */
*i = 0;
*x = xoff - ctx->ox;
*rx = nx - (xoff + nx - ctx->sx);
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
return (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
}
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
/* 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
tty_clear_line(struct tty *tty, const struct window_pane *wp, u_int py,
u_int px, u_int nx, u_int bg)
{
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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. */
if (!tty_fake_bce(tty, wp, bg)) {
/* 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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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)
{
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
struct client *c = tty->client;
u_int i, x, rx, ry;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
log_debug("%s: %s, %u at %u,%u", __func__, c->name, nx, px, py);
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
if (tty_clamp_line(tty, ctx, px, py, nx, &i, &x, &rx, &ry))
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
tty_clear_line(tty, ctx->wp, ry, x, rx, bg);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
}
/* Clamp area position to visible part of pane. */
static int
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
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)
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
{
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
u_int xoff = ctx->xoff + px, yoff = ctx->yoff + py;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
if (!tty_is_visible(tty, ctx, px, py, nx, ny))
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
return (0);
if (xoff >= ctx->ox && xoff + nx <= ctx->ox + ctx->sx) {
/* All visible. */
*i = 0;
*x = xoff - ctx->ox;
*rx = nx;
} else if (xoff < ctx->ox && xoff + nx > ctx->ox + ctx->sx) {
/* Both left and right not visible. */
*i = ctx->ox;
*x = 0;
*rx = ctx->sx;
} else if (xoff < ctx->ox) {
/* Left not visible. */
*i = ctx->ox - xoff;
*x = 0;
*rx = nx - *i;
} else {
/* Right not visible. */
*i = 0;
*x = xoff - ctx->ox;
*rx = nx - (xoff + nx - ctx->sx);
}
if (yoff >= ctx->oy && yoff + ny <= ctx->oy + ctx->sy) {
/* All visible. */
*j = 0;
*y = yoff - ctx->oy;
*ry = ny;
} else if (yoff < ctx->oy && yoff + ny > ctx->oy + ctx->sy) {
/* Both left and right not visible. */
*j = ctx->oy;
*y = 0;
*ry = ctx->sy;
} else if (yoff < ctx->oy) {
/* Left not visible. */
*j = ctx->oy - yoff;
*y = 0;
*ry = ny - *j;
} else {
/* Right not visible. */
*j = 0;
*y = yoff - ctx->oy;
*ry = ny - (yoff + ny - ctx->sy);
}
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
tty_clear_area(struct tty *tty, const struct window_pane *wp, u_int py,
u_int ny, u_int px, u_int nx, u_int bg)
{
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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. */
if (!tty_fake_bce(tty, wp, 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
*/
if (tty->term_type == TTY_VT420 && bg != 8) {
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++)
tty_clear_line(tty, wp, yy, px, nx, bg);
}
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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)
{
u_int i, j, x, y, rx, ry;
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
if (tty_clamp_area(tty, ctx, px, py, nx, ny, &i, &j, &x, &y, &rx, &ry))
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
tty_clear_area(tty, ctx->wp, y, ry, x, rx, bg);
}
static void
tty_draw_pane(struct tty *tty, const struct tty_ctx *ctx, u_int 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
{
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
struct window_pane *wp = ctx->wp;
struct screen *s = wp->screen;
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
u_int nx = screen_size_x(s), i, x, rx, ry;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
log_debug("%s: %s %u %d", __func__, tty->client->name, py, ctx->bigger);
if (!ctx->bigger) {
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
tty_draw_line(tty, wp, s, 0, py, nx, ctx->xoff, ctx->yoff);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
return;
}
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
if (tty_clamp_line(tty, ctx, 0, py, nx, &i, &x, &rx, &ry))
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
tty_draw_line(tty, wp, s, i, py, rx, x, ry);
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;
u_int n;
/* 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. */
if (tty->flags & TTY_UTF8)
return (gc);
/* Replace by the right number of underscores. */
n = gc->data.width;
if (n > UTF8_SIZE)
n = UTF8_SIZE;
memcpy(&new, gc, sizeof new);
new.data.size = n;
memset(new.data.data, '_', n);
return (&new);
}
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
tty_draw_line(struct tty *tty, const struct window_pane *wp,
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
struct screen *s, u_int px, u_int py, u_int nx, u_int atx, u_int aty)
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
struct grid_line *gl;
u_int i, j, ux, sx, width;
Use EL1 to clear lines when redrawing the leftmost pane, rather than spaces.
2017-04-16 20:32:14 +00:00
int flags, cleared = 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];
Trim trailing spaces from full line when it is clearly OK to do so.
2017-07-21 14:25:29 +00:00
size_t len, old_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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (py == 0)
gl = NULL;
else
gl = grid_get_line(gd, gd->hsize + py - 1);
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 (wp == NULL ||
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
gl == NULL ||
(~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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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) &&
!tty_fake_bce(tty, wp, 8)) {
tty_default_attributes(tty, wp, 8);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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;
}
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (px + sx != 0)
tty_cursor(tty, atx, 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
} else
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
log_debug("%s: wrapped line %u", __func__, aty);
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 &&
Simplify character replacement on non-UTF-8 terminals and make a common function.
2018-01-12 16:41:00 +00:00
((gcp->attr & GRID_ATTR_CHARSET) ||
gcp->flags != last.flags ||
gcp->attr != last.attr ||
gcp->fg != last.fg ||
gcp->bg != last.bg ||
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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)) {
Change pane redraw to collect cells up as well, and simplify it a bit.
2017-02-21 16:25:04 +00:00
tty_attributes(tty, &last, wp);
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;
}
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);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (ux + gcp->data.width > nx) {
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
tty_attributes(tty, &last, wp);
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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) {
tty_attributes(tty, &last, wp);
for (j = 0; j < gcp->data.size; j++)
tty_putc(tty, gcp->data.data[j]);
ux += gc.data.width;
} else {
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
}
}
if (len != 0) {
Trim trailing spaces from full line when it is clearly OK to do so.
2017-07-21 14:25:29 +00:00
if (grid_cells_equal(&last, &grid_default_cell)) {
old_len = len;
Use the actual width written rather than the possible width to clear.
2017-07-21 22:55:45 +00:00
while (len > 0 && buf[len - 1] == ' ') {
Trim trailing spaces from full line when it is clearly OK to do so.
2017-07-21 14:25:29 +00:00
len--;
Use the actual width written rather than the possible width to clear.
2017-07-21 22:55:45 +00:00
width--;
}
Trim trailing spaces from full line when it is clearly OK to do so.
2017-07-21 14:25:29 +00:00
log_debug("%s: trimmed %zu spaces", __func__,
old_len - len);
}
if (len != 0) {
tty_attributes(tty, &last, wp);
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;
Trim trailing spaces from full line when it is clearly OK to do so.
2017-07-21 14:25:29 +00:00
}
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
}
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (!cleared && ux < nx) {
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_default_attributes(tty, wp, 8);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
tty_clear_line(tty, wp, 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
}
tty_client_ready can not be internal to tty.c again.
2016-04-30 18:59:02 +00:00
static int
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_client_ready(struct client *c, struct window_pane *wp)
{
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);
if (c->session->curw->window != wp->window)
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
{
struct window_pane *wp = ctx->wp;
struct client *c;
if (wp == NULL)
return;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (wp->flags & (PANE_REDRAW|PANE_DROP))
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) {
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 (!tty_client_ready(c, wp))
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;
Add an option to move the status line to the top of the screen, requested by many.
2012-01-29 09:37:02 +00:00
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
ctx->bigger = tty_window_offset(&c->tty, &ctx->ox, &ctx->oy,
&ctx->sx, &ctx->sy);
Tidy up tty_write, from Sean Estabrooks.
2012-08-14 08:58:25 +00:00
ctx->xoff = wp->xoff;
ctx->yoff = wp->yoff;
Only screen-redraw.c needs to adjust for message or prompt when the status line is off, get rid of tty_status_lines and just pass the client into status_line_size so it can check the CLIENT_STATUSOFF flag as well.
2018-08-20 19:05:34 +00:00
Tidy up tty_write, from Sean Estabrooks.
2012-08-14 08:58:25 +00:00
if (status_at_line(c) == 0)
Only screen-redraw.c needs to adjust for message or prompt when the status line is off, get rid of tty_status_lines and just pass the client into status_line_size so it can check the CLIENT_STATUSOFF flag as well.
2018-08-20 19:05:34 +00:00
ctx->yoff += status_line_size(c);
Add an option to move the status line to the top of the screen, requested by many.
2012-01-29 09:37:02 +00:00
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
{
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
struct window_pane *wp = ctx->wp;
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (ctx->bigger ||
!tty_pane_full_width(tty, ctx) ||
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_fake_bce(tty, wp, ctx->bg) ||
(!tty_term_has(tty->term, TTYC_ICH) &&
!tty_term_has(tty->term, TTYC_ICH1))) {
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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;
}
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_default_attributes(tty, wp, 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
{
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
struct window_pane *wp = ctx->wp;
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (ctx->bigger ||
!tty_pane_full_width(tty, ctx) ||
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_fake_bce(tty, wp, 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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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;
}
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_default_attributes(tty, wp, 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)
{
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (ctx->bigger) {
tty_draw_pane(tty, ctx, ctx->ocy);
return;
}
ECH needs to use background colour.
2017-05-12 10:50:11 +00:00
tty_default_attributes(tty, ctx->wp, ctx->bg);
Implement ECH (erase character, CSI X). Reported by Christian Neukirchen.
2013-01-15 23:18:55 +00:00
tty_cursor_pane(tty, ctx, ctx->ocx, ctx->ocy);
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_has(tty->term, TTYC_ECH) &&
Do not check for BCE for a background colour that isn't needed, use colour 8 instead.
2017-04-18 15:27:47 +00:00
!tty_fake_bce(tty, ctx->wp, 8))
Implement ECH (erase character, CSI X). Reported by Christian Neukirchen.
2013-01-15 23:18:55 +00:00
tty_putcode1(tty, TTYC_ECH, ctx->num);
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
else
tty_repeat_space(tty, ctx->num);
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (ctx->bigger ||
!tty_pane_full_width(tty, ctx) ||
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_fake_bce(tty, ctx->wp, 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) ||
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_IL1)) {
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;
}
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_default_attributes(tty, ctx->wp, 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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (ctx->bigger ||
!tty_pane_full_width(tty, ctx) ||
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_fake_bce(tty, ctx->wp, 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) ||
!tty_term_has(tty->term, TTYC_DL1)) {
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;
}
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_default_attributes(tty, ctx->wp, 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
{
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
struct window_pane *wp = ctx->wp;
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
u_int nx;
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 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_default_attributes(tty, wp, 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
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 = screen_size_x(wp->screen);
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
tty_clear_pane_line(tty, ctx, ctx->ocy, 0, 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_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
{
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
struct window_pane *wp = ctx->wp;
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +00:00
u_int nx;
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 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_default_attributes(tty, wp, 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
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 = screen_size_x(wp->screen) - ctx->ocx;
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +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
{
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
struct window_pane *wp = ctx->wp;
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 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_default_attributes(tty, wp, ctx->bg);
Use the y offset from the context which has already been adjusted for the status line, also make tty_clamp_line adjust the y position.
2018-08-20 18:34:04 +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
{
Scrolling needs to use background colour.
2017-05-12 13:00:56 +00:00
struct window_pane *wp = ctx->wp;
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (ctx->bigger ||
!tty_pane_full_width(tty, ctx) ||
Scrolling needs to use background colour.
2017-05-12 13:00:56 +00:00
tty_fake_bce(tty, wp, 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) ||
!tty_term_has(tty->term, TTYC_RI)) {
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;
}
Scrolling needs to use background colour.
2017-05-12 13:00:56 +00:00
tty_default_attributes(tty, wp, 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);
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);
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
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_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_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
{
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
struct window_pane *wp = ctx->wp;
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (ctx->bigger ||
(!tty_pane_full_width(tty, ctx) && !tty_use_margin(tty)) ||
Do not check for BCE for a background colour that isn't needed, use colour 8 instead.
2017-04-18 15:27:47 +00:00
tty_fake_bce(tty, wp, 8) ||
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_term_has(tty->term, TTYC_CSR)) {
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;
}
Scrolling needs to use background colour.
2017-05-12 13:00:56 +00:00
tty_default_attributes(tty, wp, 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)
{
struct window_pane *wp = ctx->wp;
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
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (ctx->bigger ||
(!tty_pane_full_width(tty, ctx) && !tty_use_margin(tty)) ||
Do not check for BCE for a background colour that isn't needed, use colour 8 instead.
2017-04-18 15:27:47 +00:00
tty_fake_bce(tty, wp, 8) ||
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_term_has(tty->term, TTYC_CSR)) {
tty_redraw_region(tty, ctx);
return;
}
Scrolling needs to use background colour.
2017-05-12 13:00:56 +00:00
tty_default_attributes(tty, wp, 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 {
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
}
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
{
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
struct window_pane *wp = ctx->wp;
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
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
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_default_attributes(tty, wp, 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
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_region_pane(tty, ctx, 0, screen_size_y(wp->screen) - 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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 = screen_size_x(wp->screen);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
py = 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
ny = screen_size_y(wp->screen) - ctx->ocy - 1;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
px = ctx->ocx;
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 = screen_size_x(wp->screen) - ctx->ocx;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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
{
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
struct window_pane *wp = ctx->wp;
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
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
Add BCE for clear to start of screen, which was somehow missed.
2017-02-06 19:26:49 +00:00
tty_default_attributes(tty, wp, 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
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_region_pane(tty, ctx, 0, screen_size_y(wp->screen) - 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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 = screen_size_x(wp->screen);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
py = 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
ny = ctx->ocy - 1;
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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
{
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
struct window_pane *wp = ctx->wp;
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
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
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_default_attributes(tty, wp, 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
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_region_pane(tty, ctx, 0, screen_size_y(wp->screen) - 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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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 = screen_size_x(wp->screen);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
py = 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
ny = screen_size_y(wp->screen);
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +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
{
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
struct window_pane *wp = ctx->wp;
struct screen *s = wp->screen;
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
if (ctx->bigger) {
wp->flags |= PANE_REDRAW;
return;
}
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(tty, &grid_default_cell, wp);
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
Cleanup: use two functions for region setting, one for absolute and one inside pane.
2009-10-12 09:09:35 +00:00
tty_region_pane(tty, ctx, 0, screen_size_y(s) - 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
for (j = 0; j < screen_size_y(s); 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);
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
for (i = 0; i < screen_size_x(s); i++)
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
{
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
if (!tty_is_visible(tty, ctx, ctx->ocx, ctx->ocy, 1, 1))
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
return;
if (ctx->xoff + ctx->ocx - ctx->ox > tty->sx - 1 &&
ctx->ocy == ctx->orlower) {
Be less aggressive about turning margins off.
2017-01-11 23:10:04 +00:00
if (tty_pane_full_width(tty, ctx))
tty_region_pane(tty, ctx, ctx->orupper, ctx->orlower);
else
tty_margin_off(tty);
}
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
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
Some other tidying bits.
2017-02-08 15:49:29 +00:00
tty_cell(tty, ctx->cell, ctx->wp);
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 the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
struct window_pane *wp = ctx->wp;
Need to adjust for lines if at top.
2018-08-20 18:45:32 +00:00
if (!tty_is_visible(tty, ctx, ctx->ocx, ctx->ocy, ctx->num, 1))
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
return;
if (ctx->bigger &&
(ctx->ocx < ctx->ox || ctx->ocx + ctx->num > ctx->ox + ctx->sx)) {
if (!ctx->wrapped ||
!tty_pane_full_width(tty, ctx) ||
(tty->term->flags & TERM_EARLYWRAP) ||
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
wp->flags |= PANE_REDRAW;
return;
}
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
tty_attributes(tty, ctx->cell, ctx->wp);
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)
{
char *buf;
size_t off;
if (!tty_term_has(tty->term, TTYC_MS))
return;
off = 4 * ((ctx->num + 2) / 3) + 1; /* storage for base64 */
buf = xmalloc(off);
b64_ntop(ctx->ptr, ctx->num, buf, off);
tty_putcode_ptr2(tty, TTYC_MS, "", buf);
xfree is not particularly helpful, remove it. From Thomas Adam.
2012-07-10 11:53:01 +00:00
free(buf);
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
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static 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_cell(struct tty *tty, const struct grid_cell *gc,
const struct window_pane *wp)
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. */
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->term->flags & TERM_EARLYWRAP) &&
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;
/* Set the attributes. */
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(tty, gc, wp);
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
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
/* Get the cell and if ASCII write with putc to do ACS translation. */
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);
if (gcp->data.size == 1) {
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);
}
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 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
memcpy(&tty->last_cell, &grid_default_cell, sizeof tty->last_cell);
tty->last_wp = -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
}
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->last_wp = -1;
tty->cx = tty->cy = UINT_MAX;
tty->rupper = tty->rleft = UINT_MAX;
tty->rlower = tty->rright = UINT_MAX;
if (tty->flags & TTY_STARTED) {
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
{
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
tty_region(tty, ctx->yoff + rupper - ctx->oy,
ctx->yoff + rlower - ctx->oy);
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.
*/
if (tty->cx >= tty->sx)
tty_cursor(tty, 0, tty->cy);
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)
{
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
tty_margin(tty, ctx->xoff - ctx->ox,
ctx->xoff + ctx->wp->sx - 1 - ctx->ox);
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)
{
char s[64];
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)
snprintf(s, sizeof s, "\033[s");
else
snprintf(s, sizeof s, "\033[%u;%us", rleft + 1, rright + 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
tty_puts(tty, s);
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 ||
!tty_pane_full_width(tty, ctx) ||
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->term->flags & TERM_EARLYWRAP) ||
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)
{
Support for windows larger than the client. This adds 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. 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). 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-width -x or -y. 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 higher memory use if you make a window that big. The minimum size is the size required for the current layout including borders. This change allows some code improvements, most notably that since windows can now never be cropped, that code can be removed from the layout code, and since panes can now never be outside the size of the window, window_pane_visible can be removed.
2018-08-20 14:22:14 +00:00
tty_cursor(tty, ctx->xoff + cx - ctx->ox, ctx->yoff + cy - ctx->oy);
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
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;
} else if (change > 0 && tty_term_has(term, TTYC_CUB)) {
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;
} else if (change < 0 && tty_term_has(term, TTYC_CUF)) {
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,
const struct window_pane *wp)
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
/* Ignore cell if it is the same as the last one. */
if (wp != NULL &&
(int)wp->id == tty->last_wp &&
~(wp->window->flags & WINDOW_STYLECHANGED) &&
gc->attr == tty->last_cell.attr &&
gc->fg == tty->last_cell.fg &&
gc->bg == tty->last_cell.bg)
return;
tty->last_wp = (wp != NULL ? (int)wp->id : -1);
memcpy(&tty->last_cell, gc, sizeof tty->last_cell);
/* 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);
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
if (wp != NULL)
tty_default_colours(&gc2, wp);
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) {
if (gc2.fg != 7 && gc2.fg != 8)
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 {
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.bg != 0 && gc2.bg != 8)
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. */
Add support for the OSC 4 and OSC 104 palette setting escape sequences, from S Gilles.
2017-01-07 15:28:13 +00:00
tty_check_fg(tty, wp, &gc2);
tty_check_bg(tty, wp, &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
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
/* If any bits are being cleared, reset everything. */
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 (tc->attr & ~gc2.attr)
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
* may add to (NOT remove) the desired attributes by changing new_attr.
*/
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);
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_UNDERSCORE)
tty_putcode(tty, TTYC_SMUL);
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);
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);
}
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. */
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 == tc->fg && gc->bg == tc->bg)
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.
*/
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 || gc->bg == 8) {
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 {
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 && tc->fg != 8) {
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);
tc->fg = 8;
}
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 && tc->bg != 8) {
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);
tc->bg = 8;
}
}
}
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. */
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 && 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().
*/
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 && 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);
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
tty_check_fg(struct tty *tty, const struct window_pane *wp,
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;
if ((c = window_pane_get_palette(wp, c)) != -1)
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. */
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
if (!tty_term_has(tty->term, TTYC_SETRGBF)) {
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
colour_split_rgb(gc->fg, &r, &g, &b);
gc->fg = colour_find_rgb(r, g, b);
} else
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;
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? */
if ((tty->term->flags|tty->term_flags) & TERM_256COLOURS)
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? */
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
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;
else
gc->attr |= GRID_ATTR_BRIGHT;
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
} else
gc->attr &= ~GRID_ATTR_BRIGHT;
}
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
tty_check_bg(struct tty *tty, const struct window_pane *wp,
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) {
if ((c = window_pane_get_palette(wp, gc->bg)) != -1)
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. */
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
if (!tty_term_has(tty->term, TTYC_SETRGBB)) {
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
colour_split_rgb(gc->bg, &r, &g, &b);
gc->bg = colour_find_rgb(r, g, b);
} else
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;
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? */
if ((tty->term->flags|tty->term_flags) & TERM_256COLOURS)
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.
*/
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
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)
gc->fg += 90;
}
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;
}
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)
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
goto save_fg;
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) {
xsnprintf(s, sizeof s, "\033[%dm", gc->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_puts(tty, s);
goto save_fg;
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
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
save_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
/* 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)
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
goto save_bg;
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) {
xsnprintf(s, sizeof s, "\033[%dm", gc->bg + 10);
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
tty_puts(tty, s);
goto save_bg;
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
save_bg:
/* 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
}
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
char s[32];
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) {
/*
Upstream ncurses has introduced terminfo capabilities to specify RGB colour ("true" or "direct" colour). These consist of new entries (such as "xterm-direct") which have a different setaf/setab implementation, colors and pairs set to 0x1000000 and 0x10000, and a new RGB flag. The setaf/setab definitions seem to be geared towards what ncurses (or emacs maybe) needs, in that the new versions do only ANSI and RGB colours (they can't be used for the 256 colour palette); they rely on the silly ISO colon-separated version of SGR; and they use a weird multiplication scheme so they still only need one argument. The higher values of colors and pairs require a recent ncurses to parse. tmux can use the RGB flag to detect RGB colour support (keeping the old Tc extension for backwards compatibility for now). However, as we still want to send 256 colour information unchanged when possible, the new setaf/setab are awkward. So when RGB is present, reserve setaf/setab only for ANSI colours and use the escape sequences directly for 256 and RGB colours. (To my knowledge no recent terminal uses unusual escape sequences for these in any case.)
2018-02-04 10:10:39 +00:00
* If the user has specified -2 to the client (meaning
* TERM_256COLOURS is set), setaf and setab may not work (or
* they may not want to use them), so send the usual sequence.
*
* Also if RGB is set, setaf and setab do not support the 256
* colour palette so use the sequences directly there too.
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
*/
Upstream ncurses has introduced terminfo capabilities to specify RGB colour ("true" or "direct" colour). These consist of new entries (such as "xterm-direct") which have a different setaf/setab implementation, colors and pairs set to 0x1000000 and 0x10000, and a new RGB flag. The setaf/setab definitions seem to be geared towards what ncurses (or emacs maybe) needs, in that the new versions do only ANSI and RGB colours (they can't be used for the 256 colour palette); they rely on the silly ISO colon-separated version of SGR; and they use a weird multiplication scheme so they still only need one argument. The higher values of colors and pairs require a recent ncurses to parse. tmux can use the RGB flag to detect RGB colour support (keeping the old Tc extension for backwards compatibility for now). However, as we still want to send 256 colour information unchanged when possible, the new setaf/setab are awkward. So when RGB is present, reserve setaf/setab only for ANSI colours and use the escape sequences directly for 256 and RGB colours. (To my knowledge no recent terminal uses unusual escape sequences for these in any case.)
2018-02-04 10:10:39 +00:00
if ((tty->term_flags & TERM_256COLOURS) ||
tty_term_has(tty->term, TTYC_RGB))
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
goto fallback_256;
Use tty_term_flag not _has for XT, and make -2 force direct use of 256-colour escape sequences (so setaf/setab can be bypassed if needed).
2015-10-23 15:52:54 +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 the terminfo entry has 256 colours and setaf and setab
* exist, assume that they work correctly.
*/
if (tty->term->flags & TERM_256COLOURS) {
if (*type == '3') {
if (!tty_term_has(tty->term, TTYC_SETAF))
goto fallback_256;
tty_putcode1(tty, TTYC_SETAF, colour & 0xff);
} else {
if (!tty_term_has(tty->term, TTYC_SETAB))
goto fallback_256;
tty_putcode1(tty, TTYC_SETAB, colour & 0xff);
}
return (0);
If the terminal has colors=256, only try to use setaf/setab if they exist, reported by Filipe Brandenburger.
2015-09-25 23:30:12 +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
goto fallback_256;
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) {
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
if (*type == '3') {
if (!tty_term_has(tty->term, TTYC_SETRGBF))
return (-1);
colour_split_rgb(colour & 0xffffff, &r, &g, &b);
tty_putcode3(tty, TTYC_SETRGBF, r, g, b);
} else {
if (!tty_term_has(tty->term, TTYC_SETRGBB))
return (-1);
colour_split_rgb(colour & 0xffffff, &r, &g, &b);
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
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
fallback_256:
xsnprintf(s, sizeof s, "\033[%s;5;%dm", type, colour & 0xff);
Upstream ncurses has introduced terminfo capabilities to specify RGB colour ("true" or "direct" colour). These consist of new entries (such as "xterm-direct") which have a different setaf/setab implementation, colors and pairs set to 0x1000000 and 0x10000, and a new RGB flag. The setaf/setab definitions seem to be geared towards what ncurses (or emacs maybe) needs, in that the new versions do only ANSI and RGB colours (they can't be used for the 256 colour palette); they rely on the silly ISO colon-separated version of SGR; and they use a weird multiplication scheme so they still only need one argument. The higher values of colors and pairs require a recent ncurses to parse. tmux can use the RGB flag to detect RGB colour support (keeping the old Tc extension for backwards compatibility for now). However, as we still want to send 256 colour information unchanged when possible, the new setaf/setab are awkward. So when RGB is present, reserve setaf/setab only for ANSI colours and use the escape sequences directly for 256 and RGB colours. (To my knowledge no recent terminal uses unusual escape sequences for these in any case.)
2018-02-04 10:10:39 +00:00
log_debug("%s: 256 colour fallback: %s", tty->client->name, s);
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
tty_puts(tty, s);
return (0);
}
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static 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_default_colours(struct grid_cell *gc, const struct window_pane *wp)
{
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
struct window *w = wp->window;
struct options *oo = w->options;
const struct grid_cell *agc, *pgc, *wgc;
Fix setting the palette of aixterm colours (90-97).
2017-01-12 00:19:32 +00:00
int c;
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
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
if (w->flags & WINDOW_STYLECHANGED) {
w->flags &= ~WINDOW_STYLECHANGED;
agc = options_get_style(oo, "window-active-style");
memcpy(&w->active_style, agc, sizeof w->active_style);
wgc = options_get_style(oo, "window-style");
memcpy(&w->style, wgc, sizeof w->style);
} else {
agc = &w->active_style;
wgc = &w->style;
}
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
pgc = &wp->colgc;
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) {
if (pgc->fg != 8)
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
gc->fg = pgc->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 if (wp == w->active && agc->fg != 8)
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
gc->fg = agc->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
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
gc->fg = wgc->fg;
Add support for the OSC 4 and OSC 104 palette setting escape sequences, from S Gilles.
2017-01-07 15:28:13 +00:00
Fix setting the palette of aixterm colours (90-97).
2017-01-12 00:19:32 +00:00
if (gc->fg != 8 &&
(c = window_pane_get_palette(wp, gc->fg)) != -1)
gc->fg = c;
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) {
if (pgc->bg != 8)
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
gc->bg = pgc->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 if (wp == w->active && agc->bg != 8)
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
gc->bg = agc->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
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
gc->bg = wgc->bg;
Add support for the OSC 4 and OSC 104 palette setting escape sequences, from S Gilles.
2017-01-07 15:28:13 +00:00
Fix setting the palette of aixterm colours (90-97).
2017-01-12 00:19:32 +00:00
if (gc->bg != 8 &&
(c = window_pane_get_palette(wp, gc->bg)) != -1)
gc->bg = c;
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
tty_default_attributes(struct tty *tty, const struct window_pane *wp, u_int bg)
{
static struct grid_cell gc;
memcpy(&gc, &grid_default_cell, sizeof gc);
gc.bg = bg;
tty_attributes(tty, &gc, wp);
}
Reference in New Issue Copy Permalink