circlecloud/tmux
1
0
Fork 0
mirror of https://github.com/tmux/tmux.git synced 2024-10-31 22:58:49 +00:00
Code Issues Projects Releases Wiki Activity
bf5d3f2e26
tmux/grid.c

1536 lines
34 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) 2008 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>
xfree is not particularly helpful, remove it. From Thomas Adam.
2012-07-10 11:53:01 +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 "tmux.h"
/*
* Grid data. This is the basic data structure that represents what is shown on
* screen.
*
* A grid is a grid of cells (struct grid_cell). Lines are not allocated until
* cells in that line are written to. The grid is split into history and
* viewable data with the history starting at row (line) 0 and extending to
* (hsize - 1); from hsize to hsize + (sy - 1) is the viewable data. All
* functions in this file work on absolute coordinates, grid-view.c has
* functions which work on the screen data.
*/
/* Default grid cell data. */
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
const struct grid_cell grid_default_cell = {
Use 8 for underscore colour defaults instead of 0 which is less confusing, and fix writing tge default colour. GitHub issue 3627.
2023-07-13 06:03:48 +00:00
{ { ' ' }, 0, 1, 1 }, 0, 0, 8, 8, 8, 0
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
};
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
Move the code to set up a padding cell into grid.c.
2020-06-02 20:51:46 +00:00
/*
* Padding grid cell data. Padding cells are the only zero width cell that
* appears in the grid - because of this, they are always extended cells.
*/
static const struct grid_cell grid_padding_cell = {
Use 8 for underscore colour defaults instead of 0 which is less confusing, and fix writing tge default colour. GitHub issue 3627.
2023-07-13 06:03:48 +00:00
{ { '!' }, 0, 0, 0 }, 0, GRID_FLAG_PADDING, 8, 8, 8, 0
Move the code to set up a padding cell into grid.c.
2020-06-02 20:51:46 +00:00
};
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
/* Cleared grid cell data. */
Move the code to set up a padding cell into grid.c.
2020-06-02 20:51:46 +00:00
static const struct grid_cell grid_cleared_cell = {
Use 8 for underscore colour defaults instead of 0 which is less confusing, and fix writing tge default colour. GitHub issue 3627.
2023-07-13 06:03:48 +00:00
{ { ' ' }, 0, 1, 1 }, 0, GRID_FLAG_CLEARED, 8, 8, 8, 0
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
};
static const struct grid_cell_entry grid_cleared_entry = {
Reorder struct grid_cell_entry On aarch64 with llvm 15, the new -Wunaligned-access emits noise on every one of tmux's source files. This avoids this warning by moving a u_char to the end of the struct. This does not change the size of the struct on any architecture. ok nicm
2023-05-08 10:03:39 +00:00
{ .data = { 0, 8, 8, ' ' } }, GRID_FLAG_CLEARED
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09: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
Add a helper to store a cell, and some tidying.
2017-02-08 15:41:41 +00:00
/* Store cell in entry. */
static void
grid_store_cell(struct grid_cell_entry *gce, const struct grid_cell *gc,
u_char c)
{
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
gce->flags = (gc->flags & ~GRID_FLAG_CLEARED);
Add a helper to store a cell, and some tidying.
2017-02-08 15:41:41 +00:00
gce->data.fg = gc->fg & 0xff;
if (gc->fg & COLOUR_FLAG_256)
gce->flags |= GRID_FLAG_FG256;
gce->data.bg = gc->bg & 0xff;
if (gc->bg & COLOUR_FLAG_256)
gce->flags |= GRID_FLAG_BG256;
gce->data.attr = gc->attr;
gce->data.data = c;
}
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
/* Check if a cell should be an extended cell. */
Collected cells may still need to be extended for RGB colours.
2017-02-13 16:05:30 +00:00
static int
grid_need_extended_cell(const struct grid_cell_entry *gce,
const struct grid_cell *gc)
{
if (gce->flags & GRID_FLAG_EXTENDED)
return (1);
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 (gc->attr > 0xff)
return (1);
Allow UTF-8 characters of width 0 to be stored, it is useful to be able to put padding cells in as width 0.
2020-06-02 20:10:23 +00:00
if (gc->data.size != 1 || gc->data.width != 1)
Collected cells may still need to be extended for RGB colours.
2017-02-13 16:05:30 +00:00
return (1);
Style nits and a missing cast.
2017-04-19 12:44:29 +00:00
if ((gc->fg & COLOUR_FLAG_RGB) || (gc->bg & COLOUR_FLAG_RGB))
Collected cells may still need to be extended for RGB colours.
2017-02-13 16:05:30 +00:00
return (1);
Add support for underscore colours with Setulc capability, mostly from Kai Moschcau.
2019-06-27 15:17:41 +00:00
if (gc->us != 0) /* only supports 256 or RGB */
return (1);
Add support for OSC 8 hyperlinks (a VTE extension now supported by other terminals such as iTerm2). Originally written by me then extended and completed by first Will Noble and later Jeff Chiang. GitHub issues 911, 2621, 2890, 3240.
2022-06-30 09:55:53 +00:00
if (gc->link != 0)
return (1);
Collected cells may still need to be extended for RGB colours.
2017-02-13 16:05:30 +00:00
return (0);
}
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
/* Get an extended cell. */
static void
grid_get_extended_cell(struct grid_line *gl, struct grid_cell_entry *gce,
int flags)
{
u_int at = gl->extdsize + 1;
gl->extddata = xreallocarray(gl->extddata, at, sizeof *gl->extddata);
gl->extdsize = at;
gce->offset = at - 1;
gce->flags = (flags | GRID_FLAG_EXTENDED);
}
/* Set cell as extended. */
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
static struct grid_extd_entry *
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
grid_extended_cell(struct grid_line *gl, struct grid_cell_entry *gce,
const struct grid_cell *gc)
{
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
struct grid_extd_entry *gee;
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
int flags = (gc->flags & ~GRID_FLAG_CLEARED);
Do not take the address of a potentially unaligned member.
2020-06-05 09:35:41 +00:00
utf8_char uc;
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
if (~gce->flags & GRID_FLAG_EXTENDED)
grid_get_extended_cell(gl, gce, flags);
else if (gce->offset >= gl->extdsize)
fatalx("offset too big");
gl->flags |= GRID_LINE_EXTENDED;
Do not take the address of a potentially unaligned member.
2020-06-05 09:35:41 +00:00
utf8_from_data(&gc->data, &uc);
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
gee = &gl->extddata[gce->offset];
Do not take the address of a potentially unaligned member.
2020-06-05 09:35:41 +00:00
gee->data = uc;
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
gee->attr = gc->attr;
gee->flags = flags;
gee->fg = gc->fg;
gee->bg = gc->bg;
gee->us = gc->us;
Add support for OSC 8 hyperlinks (a VTE extension now supported by other terminals such as iTerm2). Originally written by me then extended and completed by first Will Noble and later Jeff Chiang. GitHub issues 911, 2621, 2890, 3240.
2022-06-30 09:55:53 +00:00
gee->link = gc->link;
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
return (gee);
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
}
Previously, extended cell data was never reduced in size even when the cell was overwritten. With a large history this can be a substantial amount of memory. To reduce this, compact each extended cell list to only cells in use as it is scrolled off the visible screen into the history. From Dan Aloni in GitHub issue 1062.
2017-09-10 14:36:12 +00:00
/* Free up unused extended cells. */
static void
grid_compact_line(struct grid_line *gl)
{
int new_extdsize = 0;
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
struct grid_extd_entry *new_extddata;
Previously, extended cell data was never reduced in size even when the cell was overwritten. With a large history this can be a substantial amount of memory. To reduce this, compact each extended cell list to only cells in use as it is scrolled off the visible screen into the history. From Dan Aloni in GitHub issue 1062.
2017-09-10 14:36:12 +00:00
struct grid_cell_entry *gce;
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
struct grid_extd_entry *gee;
Previously, extended cell data was never reduced in size even when the cell was overwritten. With a large history this can be a substantial amount of memory. To reduce this, compact each extended cell list to only cells in use as it is scrolled off the visible screen into the history. From Dan Aloni in GitHub issue 1062.
2017-09-10 14:36:12 +00:00
u_int px, idx;
if (gl->extdsize == 0)
return;
for (px = 0; px < gl->cellsize; px++) {
gce = &gl->celldata[px];
if (gce->flags & GRID_FLAG_EXTENDED)
new_extdsize++;
}
if (new_extdsize == 0) {
free(gl->extddata);
gl->extddata = NULL;
gl->extdsize = 0;
return;
}
new_extddata = xreallocarray(NULL, new_extdsize, sizeof *gl->extddata);
idx = 0;
for (px = 0; px < gl->cellsize; px++) {
gce = &gl->celldata[px];
if (gce->flags & GRID_FLAG_EXTENDED) {
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
gee = &gl->extddata[gce->offset];
memcpy(&new_extddata[idx], gee, sizeof *gee);
Previously, extended cell data was never reduced in size even when the cell was overwritten. With a large history this can be a substantial amount of memory. To reduce this, compact each extended cell list to only cells in use as it is scrolled off the visible screen into the history. From Dan Aloni in GitHub issue 1062.
2017-09-10 14:36:12 +00:00
gce->offset = idx++;
}
}
free(gl->extddata);
gl->extddata = new_extddata;
gl->extdsize = new_extdsize;
}
Add function comments.
2018-07-11 06:43:45 +00:00
/* Get line data. */
Add accessors for grid linedata member, for some future work. From Dan Aloni.
2018-07-04 09:44:07 +00:00
struct grid_line *
grid_get_line(struct grid *gd, u_int line)
{
return (&gd->linedata[line]);
}
Add function comments.
2018-07-11 06:43:45 +00:00
/* Adjust number of lines. */
Add accessors for grid linedata member, for some future work. From Dan Aloni.
2018-07-04 09:44:07 +00:00
void
grid_adjust_lines(struct grid *gd, u_int lines)
{
gd->linedata = xreallocarray(gd->linedata, lines, sizeof *gd->linedata);
}
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
/* Copy default into a cell. */
static void
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
grid_clear_cell(struct grid *gd, u_int px, u_int py, u_int bg)
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
{
Make grid_clear_cell set up the entry properly for 256 and RGB cells.
2016-10-18 14:56:17 +00:00
struct grid_line *gl = &gd->linedata[py];
struct grid_cell_entry *gce = &gl->celldata[px];
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
struct grid_extd_entry *gee;
Make grid_clear_cell set up the entry properly for 256 and RGB cells.
2016-10-18 14:56:17 +00:00
Set a flag on cells are genuinely empty (cleared and never written to) and use tty_clear_line (which will choose the best escape sequence) to clear any batches of cells with that flag when redrawing a line from the stored screen.
2019-03-12 23:21:45 +00:00
memcpy(gce, &grid_cleared_entry, sizeof *gce);
Some minor performance improvements - most notably, don't search the input state table if the next character matches the same state as before.
2019-09-24 20:44:58 +00:00
if (bg != 8) {
if (bg & COLOUR_FLAG_RGB) {
grid_get_extended_cell(gl, gce, gce->flags);
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
gee = grid_extended_cell(gl, gce, &grid_cleared_cell);
gee->bg = bg;
Some minor performance improvements - most notably, don't search the input state table if the next character matches the same state as before.
2019-09-24 20:44:58 +00:00
} else {
if (bg & COLOUR_FLAG_256)
gce->flags |= GRID_FLAG_BG256;
gce->data.bg = bg;
}
Make grid_clear_cell set up the entry properly for 256 and RGB cells.
2016-10-18 14:56:17 +00:00
}
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
}
Remove some stuff that accidentally ended up here from portable, and remove a little-used debug function.
2015-05-08 15:56:49 +00:00
/* Check grid y position. */
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
static int
Style nits in function arguments.
2019-12-03 10:47:22 +00:00
grid_check_y(struct grid *gd, const char *from, u_int py)
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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 mouse on preview in tree mode.
2017-11-03 17:02:33 +00:00
if (py >= gd->hsize + gd->sy) {
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
log_debug("%s: y out of range: %u", from, py);
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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 (-1);
}
return (0);
}
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
/* Check if two styles are (visibly) the same. */
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
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
grid_cells_look_equal(const struct grid_cell *gc1, const struct grid_cell *gc2)
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
{
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
if (gc1->fg != gc2->fg || gc1->bg != gc2->bg)
return (0);
if (gc1->attr != gc2->attr || gc1->flags != gc2->flags)
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);
Add support for OSC 8 hyperlinks (a VTE extension now supported by other terminals such as iTerm2). Originally written by me then extended and completed by first Will Noble and later Jeff Chiang. GitHub issues 911, 2621, 2890, 3240.
2022-06-30 09:55:53 +00:00
if (gc1->link != gc2->link)
return (0);
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
return (1);
}
/* Compare grid cells. Return 1 if equal, 0 if not. */
int
grid_cells_equal(const struct grid_cell *gc1, const struct grid_cell *gc2)
{
if (!grid_cells_look_equal(gc1, gc2))
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);
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
if (gc1->data.width != gc2->data.width)
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);
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
if (gc1->data.size != gc2->data.size)
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);
Use a grid cell not a style for the pane style.
2020-05-16 14:53:23 +00:00
return (memcmp(gc1->data.data, gc2->data.data, gc1->data.size) == 0);
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
}
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
/* Free one line. */
static void
grid_free_line(struct grid *gd, u_int py)
{
free(gd->linedata[py].celldata);
gd->linedata[py].celldata = NULL;
free(gd->linedata[py].extddata);
gd->linedata[py].extddata = NULL;
}
/* Free several lines. */
static void
grid_free_lines(struct grid *gd, u_int py, u_int ny)
{
u_int yy;
for (yy = py; yy < py + ny; yy++)
grid_free_line(gd, yy);
}
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
/* Create a new grid. */
struct grid *
grid_create(u_int sx, u_int sy, u_int hlimit)
{
struct grid *gd;
gd = xmalloc(sizeof *gd);
gd->sx = sx;
gd->sy = sy;
Do not set the history flag if there is no history.
2020-03-19 13:46:10 +00:00
if (hlimit != 0)
gd->flags = GRID_HISTORY;
else
gd->flags = 0;
Support "alternate screen" mode (terminfo smcup/rmcup) typically used by full screen interactive programs to preserve the screen contents. When activated, it saves a copy of the visible grid and disables scrolling into and resizing out of the history; when deactivated the visible data is restored and the history reenabled.
2009-07-13 10:43:52 +00:00
Remember the number of lines scrolled into the history (versus cleared into the history) and when resizing only use scrolled lines and not cleared lines (which are probably not intended to reappear). From Chaoren Lin.
2016-09-02 20:57:20 +00:00
gd->hscrolled = 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
gd->hsize = 0;
gd->hlimit = hlimit;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
if (gd->sy != 0)
gd->linedata = xcalloc(gd->sy, sizeof *gd->linedata);
else
gd->linedata = 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
return (gd);
}
/* Destroy grid. */
void
grid_destroy(struct grid *gd)
{
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
grid_free_lines(gd, 0, gd->hsize + gd->sy);
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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(gd->linedata);
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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(gd);
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
}
/* Compare grids. */
int
grid_compare(struct grid *ga, struct grid *gb)
{
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
struct grid_line *gla, *glb;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
struct grid_cell gca, gcb;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
u_int xx, yy;
Couple of fixes from cppcheck via Tiago Cunha.
2014-01-15 11:44:18 +00:00
if (ga->sx != gb->sx || ga->sy != gb->sy)
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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 (1);
for (yy = 0; yy < ga->sy; yy++) {
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
gla = &ga->linedata[yy];
glb = &gb->linedata[yy];
if (gla->cellsize != glb->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
return (1);
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
for (xx = 0; xx < gla->cellsize; xx++) {
grid_get_cell(ga, xx, yy, &gca);
grid_get_cell(gb, xx, yy, &gcb);
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 (!grid_cells_equal(&gca, &gcb))
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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 (1);
}
}
return (0);
}
Helper function to shorten history.
2018-07-11 06:51:39 +00:00
/* Trim lines from the history. */
static void
grid_trim_history(struct grid *gd, u_int ny)
{
grid_free_lines(gd, 0, ny);
memmove(&gd->linedata[0], &gd->linedata[ny],
(gd->hsize + gd->sy - ny) * (sizeof *gd->linedata));
}
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
/*
* Collect lines from the history if at the limit. Free the top (oldest) 10%
* and shift up.
*/
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
grid_collect_history(struct grid *gd)
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
{
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
u_int ny;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Do not free more lines than are available in the history.
2017-09-11 06:40:46 +00:00
if (gd->hsize == 0 || gd->hsize < gd->hlimit)
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +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
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
ny = gd->hlimit / 10;
if (ny < 1)
ny = 1;
Do not free more lines than are available in the history.
2017-09-11 06:40:46 +00:00
if (ny > gd->hsize)
ny = gd->hsize;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
/*
* Free the lines from 0 to ny then move the remaining lines over
* them.
*/
Helper function to shorten history.
2018-07-11 06:51:39 +00:00
grid_trim_history(gd, ny);
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
gd->hsize -= ny;
Remember the number of lines scrolled into the history (versus cleared into the history) and when resizing only use scrolled lines and not cleared lines (which are probably not intended to reappear). From Chaoren Lin.
2016-09-02 20:57:20 +00:00
if (gd->hscrolled > gd->hsize)
gd->hscrolled = gd->hsize;
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
}
Add a -T flag to resize-pane to trim lines below the cursor, moving lines out of the history. GitHub issue 2134.
2020-03-31 17:13:20 +00:00
/* Remove lines from the bottom of the history. */
void
grid_remove_history(struct grid *gd, u_int ny)
{
u_int yy;
if (ny > gd->hsize)
return;
for (yy = 0; yy < ny; yy++)
grid_free_line(gd, gd->hsize + gd->sy - 1 - yy);
gd->hsize -= ny;
}
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
/*
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
* Scroll the entire visible screen, moving one line into the history. Just
* allocate a new line at the bottom and move the history size indicator.
*/
void
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
grid_scroll_history(struct grid *gd, u_int bg)
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
{
u_int yy;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
yy = gd->hsize + gd->sy;
Add xreallocarray and remove nmemb argument from xrealloc.
2014-10-08 17:35:58 +00:00
gd->linedata = xreallocarray(gd->linedata, yy + 1,
sizeof *gd->linedata);
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
grid_empty_line(gd, yy, 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
Remember the number of lines scrolled into the history (versus cleared into the history) and when resizing only use scrolled lines and not cleared lines (which are probably not intended to reappear). From Chaoren Lin.
2016-09-02 20:57:20 +00:00
gd->hscrolled++;
Previously, extended cell data was never reduced in size even when the cell was overwritten. With a large history this can be a substantial amount of memory. To reduce this, compact each extended cell list to only cells in use as it is scrolled off the visible screen into the history. From Dan Aloni in GitHub issue 1062.
2017-09-10 14:36:12 +00:00
grid_compact_line(&gd->linedata[gd->hsize]);
Store time lines are scrolled into history and display in copy mode.
2022-06-21 09:30:01 +00:00
gd->linedata[gd->hsize].time = current_time;
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
gd->hsize++;
}
Free the history when it is cleared, based on a diff from Carlo Cannas.
2015-09-25 15:53:07 +00:00
/* Clear the history. */
void
grid_clear_history(struct grid *gd)
{
Helper function to shorten history.
2018-07-11 06:51:39 +00:00
grid_trim_history(gd, gd->hsize);
Free the history when it is cleared, based on a diff from Carlo Cannas.
2015-09-25 15:53:07 +00:00
Remember the number of lines scrolled into the history (versus cleared into the history) and when resizing only use scrolled lines and not cleared lines (which are probably not intended to reappear). From Chaoren Lin.
2016-09-02 20:57:20 +00:00
gd->hscrolled = 0;
Free the history when it is cleared, based on a diff from Carlo Cannas.
2015-09-25 15:53:07 +00:00
gd->hsize = 0;
Remember the number of lines scrolled into the history (versus cleared into the history) and when resizing only use scrolled lines and not cleared lines (which are probably not intended to reappear). From Chaoren Lin.
2016-09-02 20:57:20 +00:00
Free the history when it is cleared, based on a diff from Carlo Cannas.
2015-09-25 15:53:07 +00:00
gd->linedata = xreallocarray(gd->linedata, gd->sy,
sizeof *gd->linedata);
}
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
/* Scroll a region up, moving the top line into the history. */
void
Scrolling needs to use background colour.
2017-05-12 13:00:56 +00:00
grid_scroll_history_region(struct grid *gd, u_int upper, u_int lower, u_int bg)
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
{
Some other unused variables.
2017-05-13 07:30:50 +00:00
struct grid_line *gl_history, *gl_upper;
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
u_int yy;
/* Create a space for a new line. */
yy = gd->hsize + gd->sy;
Add xreallocarray and remove nmemb argument from xrealloc.
2014-10-08 17:35:58 +00:00
gd->linedata = xreallocarray(gd->linedata, yy + 1,
sizeof *gd->linedata);
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
/* Move the entire screen down to free a space for this line. */
gl_history = &gd->linedata[gd->hsize];
memmove(gl_history + 1, gl_history, gd->sy * sizeof *gl_history);
/* Adjust the region and find its start and end. */
upper++;
gl_upper = &gd->linedata[upper];
lower++;
/* Move the line into the history. */
memcpy(gl_history, gl_upper, sizeof *gl_history);
Store time lines are scrolled into history and display in copy mode.
2022-06-21 09:30:01 +00:00
gl_history->time = current_time;
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
/* Then move the region up and clear the bottom line. */
memmove(gl_upper, gl_upper + 1, (lower - upper) * sizeof *gl_upper);
Scrolling needs to use background colour.
2017-05-12 13:00:56 +00:00
grid_empty_line(gd, lower, 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
Move lines into the history when scrolling even if the scroll region is not the entire screen. Allows ircII users to see history, prompted by naddy.
2009-10-13 15:38:37 +00:00
/* Move the history offset down over the line. */
Remember the number of lines scrolled into the history (versus cleared into the history) and when resizing only use scrolled lines and not cleared lines (which are probably not intended to reappear). From Chaoren Lin.
2016-09-02 20:57:20 +00:00
gd->hscrolled++;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
gd->hsize++;
}
/* Expand line to fit to cell. */
Add static in window-*.c and move some internal functions out of tmux.h.
2016-10-11 13:21:59 +00:00
static void
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
grid_expand_line(struct grid *gd, u_int py, u_int sx, u_int 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
{
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
struct grid_line *gl;
Stick line length to what is actually used (removing an optimization that allowed it to be bigger), and use clear line/EOL sequences rather than spaces in copy/scroll mode. This fixes xterm copy/paste from tmux which treats trailing spaces differently from clearing a line with the escape sequences. Reported by martynas@.
2009-09-15 15:14:09 +00:00
u_int xx;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
gl = &gd->linedata[py];
Stick line length to what is actually used (removing an optimization that allowed it to be bigger), and use clear line/EOL sequences rather than spaces in copy/scroll mode. This fixes xterm copy/paste from tmux which treats trailing spaces differently from clearing a line with the escape sequences. Reported by martynas@.
2009-09-15 15:14:09 +00:00
if (sx <= gl->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
return;
Tweak how much we expand lines by.
2017-02-08 08:26:35 +00:00
if (sx < gd->sx / 4)
sx = gd->sx / 4;
else if (sx < gd->sx / 2)
sx = gd->sx / 2;
Do not force line width to grid width because it may need to be larger to accomodate a wide character. GitHub issue 2336.
2020-08-07 07:02:57 +00:00
else if (gd->sx > sx)
Tweak how much we expand lines by.
2017-02-08 08:26:35 +00:00
sx = gd->sx;
Expand lines more aggressively to reduce rate of allocations.
2017-02-03 20:53:03 +00:00
Add xreallocarray and remove nmemb argument from xrealloc.
2014-10-08 17:35:58 +00:00
gl->celldata = xreallocarray(gl->celldata, sx, sizeof *gl->celldata);
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
for (xx = gl->cellsize; xx < sx; xx++)
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
grid_clear_cell(gd, xx, py, bg);
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
gl->cellsize = 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
}
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
/* Empty a line and set background colour if needed. */
Use grid_empty_line rather than memset when adding new lines on resize. Also remove some old test code.
2020-04-15 12:59:20 +00:00
void
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
grid_empty_line(struct grid *gd, u_int py, u_int bg)
{
memset(&gd->linedata[py], 0, sizeof gd->linedata[py]);
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
if (!COLOUR_DEFAULT(bg))
Add support for BCE (background colour erase). This makes various escape sequences (notable EL and ED but also IL, DL, ICH, DCH) create blank cells using the current background colour rather than the default colour. On modern systems BCE doesn't really have many benefits, but most other terminals now support it, some (lazy) applications rely on it, and it is not hard to include now that we have pane background colours anyway. Mostly written by Sean Haugh.
2016-10-13 20:27:27 +00:00
grid_expand_line(gd, py, gd->sx, bg);
}
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
/* Peek at grid line. */
const struct grid_line *
grid_peek_line(struct grid *gd, u_int py)
{
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py) != 0)
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
return (NULL);
return (&gd->linedata[py]);
}
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/* Get cell from line. */
static void
grid_get_cell1(struct grid_line *gl, u_int px, 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
{
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
struct grid_cell_entry *gce = &gl->celldata[px];
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
struct grid_extd_entry *gee;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
if (gce->flags & GRID_FLAG_EXTENDED) {
if (gce->offset >= gl->extdsize)
memcpy(gc, &grid_default_cell, sizeof *gc);
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
else {
gee = &gl->extddata[gce->offset];
gc->flags = gee->flags;
gc->attr = gee->attr;
gc->fg = gee->fg;
gc->bg = gee->bg;
gc->us = gee->us;
Add support for OSC 8 hyperlinks (a VTE extension now supported by other terminals such as iTerm2). Originally written by me then extended and completed by first Will Noble and later Jeff Chiang. GitHub issues 911, 2621, 2890, 3240.
2022-06-30 09:55:53 +00:00
gc->link = gee->link;
Tidy up new UTF-8 code and make it more generic.
2020-05-25 18:19:29 +00:00
utf8_to_data(gee->data, &gc->data);
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
}
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
return;
}
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
gc->flags = gce->flags & ~(GRID_FLAG_FG256|GRID_FLAG_BG256);
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
gc->attr = gce->data.attr;
gc->fg = gce->data.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
if (gce->flags & GRID_FLAG_FG256)
gc->fg |= COLOUR_FLAG_256;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
gc->bg = gce->data.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
if (gce->flags & GRID_FLAG_BG256)
gc->bg |= COLOUR_FLAG_256;
Use 8 for underscore colour defaults instead of 0 which is less confusing, and fix writing tge default colour. GitHub issue 3627.
2023-07-13 06:03:48 +00:00
gc->us = 8;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
utf8_set(&gc->data, gce->data.data);
Add support for OSC 8 hyperlinks (a VTE extension now supported by other terminals such as iTerm2). Originally written by me then extended and completed by first Will Noble and later Jeff Chiang. GitHub issues 911, 2621, 2890, 3240.
2022-06-30 09:55:53 +00:00
gc->link = 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
}
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/* Get cell for reading. */
void
grid_get_cell(struct grid *gd, u_int px, u_int py, struct grid_cell *gc)
{
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py) != 0 ||
Mode init needs to be fired with the mode on the list or it will not be resized correctly.
2019-03-18 15:25:36 +00:00
px >= gd->linedata[py].cellsize)
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
memcpy(gc, &grid_default_cell, sizeof *gc);
Mode init needs to be fired with the mode on the list or it will not be resized correctly.
2019-03-18 15:25:36 +00:00
else
grid_get_cell1(&gd->linedata[py], px, gc);
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
}
Move the code to set up a padding cell into grid.c.
2020-06-02 20:51:46 +00:00
/* Set cell at position. */
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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
Trivial style and spacing nits.
2013-10-10 12:01:14 +00:00
grid_set_cell(struct grid *gd, u_int px, u_int py, 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
{
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
struct grid_line *gl;
struct grid_cell_entry *gce;
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py) != 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
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
grid_expand_line(gd, py, px + 1, 8);
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
gl = &gd->linedata[py];
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 (px + 1 > gl->cellused)
gl->cellused = px + 1;
Add a helper to store a cell, and some tidying.
2017-02-08 15:41:41 +00:00
gce = &gl->celldata[px];
Collected cells may still need to be extended for RGB colours.
2017-02-13 16:05:30 +00:00
if (grid_need_extended_cell(gce, gc))
Make grid_clear_cell set up the entry properly for 256 and RGB cells.
2016-10-18 14:56:17 +00:00
grid_extended_cell(gl, gce, gc);
Add a helper to store a cell, and some tidying.
2017-02-08 15:41:41 +00:00
else
grid_store_cell(gce, gc, gc->data.data[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
}
Move the code to set up a padding cell into grid.c.
2020-06-02 20:51:46 +00:00
/* Set padding at position. */
void
grid_set_padding(struct grid *gd, u_int px, u_int py)
{
grid_set_cell(gd, px, py, &grid_padding_cell);
}
/* Set cells at position. */
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
grid_set_cells(struct grid *gd, u_int px, u_int py, const struct grid_cell *gc,
const char *s, size_t slen)
{
struct grid_line *gl;
struct grid_cell_entry *gce;
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
struct grid_extd_entry *gee;
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
u_int i;
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py) != 0)
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
return;
grid_expand_line(gd, py, px + slen, 8);
gl = &gd->linedata[py];
if (px + slen > gl->cellused)
gl->cellused = px + slen;
for (i = 0; i < slen; i++) {
gce = &gl->celldata[px + i];
Collected cells may still need to be extended for RGB colours.
2017-02-13 16:05:30 +00:00
if (grid_need_extended_cell(gce, gc)) {
Instead of storing all UTF-8 characters in the extended cell which means that 14 bytes are wasted for each character in the BMP, only store characters of three bytes or less in the cell itself and store others (outside the BMP or with combining characters) in a separate global tree. Can reduce grid memory use for heavy Unicode users by around 30%.
2020-05-25 09:32:10 +00:00
gee = grid_extended_cell(gl, gce, gc);
Allow UTF-8 characters of width 0 to be stored, it is useful to be able to put padding cells in as width 0.
2020-06-02 20:10:23 +00:00
gee->data = utf8_build_one(s[i]);
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
} else
grid_store_cell(gce, gc, s[i]);
}
}
Stick line length to what is actually used (removing an optimization that allowed it to be bigger), and use clear line/EOL sequences rather than spaces in copy/scroll mode. This fixes xterm copy/paste from tmux which treats trailing spaces differently from clearing a line with the escape sequences. Reported by martynas@.
2009-09-15 15:14:09 +00:00
/* Clear area. */
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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
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
grid_clear(struct grid *gd, u_int px, u_int py, u_int nx, u_int ny, u_int 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
{
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
struct grid_line *gl;
Fix grid clear code to correctly clear with the default background colour rather than ending up with the used count higher than the total size, GitHub issue 1829.
2019-07-16 10:30:56 +00:00
u_int xx, yy, ox, 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
if (nx == 0 || ny == 0)
return;
if (px == 0 && nx == gd->sx) {
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
grid_clear_lines(gd, py, ny, 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
return;
}
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py) != 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
return;
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py + ny - 1) != 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
return;
for (yy = py; yy < py + ny; yy++) {
Add a "terminal" colour which can be used instead of "default" in style options for the terminal default colour, bypassing any inheritance from other options. Prompted by a discussion with abieber@.
2018-10-25 15:13:38 +00:00
gl = &gd->linedata[yy];
Fix grid clear code to correctly clear with the default background colour rather than ending up with the used count higher than the total size, GitHub issue 1829.
2019-07-16 10:30:56 +00:00
sx = gd->sx;
if (sx > gl->cellsize)
sx = gl->cellsize;
ox = nx;
if (COLOUR_DEFAULT(bg)) {
if (px > sx)
continue;
if (px + nx > sx)
ox = sx - px;
Stick line length to what is actually used (removing an optimization that allowed it to be bigger), and use clear line/EOL sequences rather than spaces in copy/scroll mode. This fixes xterm copy/paste from tmux which treats trailing spaces differently from clearing a line with the escape sequences. Reported by martynas@.
2009-09-15 15:14:09 +00:00
}
Fix grid clear code to correctly clear with the default background colour rather than ending up with the used count higher than the total size, GitHub issue 1829.
2019-07-16 10:30:56 +00:00
grid_expand_line(gd, yy, px + ox, 8); /* default bg first */
for (xx = px; xx < px + ox; xx++)
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
grid_clear_cell(gd, xx, yy, 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
}
}
/* Clear lines. This just frees and truncates the lines. */
void
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
grid_clear_lines(struct grid *gd, u_int py, u_int ny, u_int 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
{
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
u_int yy;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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 (ny == 0)
return;
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py) != 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
return;
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py + ny - 1) != 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
return;
for (yy = py; yy < py + ny; yy++) {
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
grid_free_line(gd, yy);
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
grid_empty_line(gd, yy, 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
}
Reset wrapped flag when clearing or moving lines, GitHub issue 2215.
2020-06-04 21:41:31 +00:00
if (py != 0)
gd->linedata[py - 1].flags &= ~GRID_LINE_WRAPPED;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
}
/* Move a group of lines. */
void
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
grid_move_lines(struct grid *gd, u_int dy, u_int py, u_int ny, u_int 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
{
u_int yy;
if (ny == 0 || py == dy)
return;
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py) != 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
return;
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py + ny - 1) != 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
return;
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, dy) != 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
return;
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, dy + ny - 1) != 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
return;
/* Free any lines which are being replaced. */
for (yy = dy; yy < dy + ny; yy++) {
if (yy >= py && yy < py + ny)
continue;
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
grid_free_line(gd, yy);
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
}
Reset wrapped flag when clearing or moving lines, GitHub issue 2215.
2020-06-04 21:41:31 +00:00
if (dy != 0)
gd->linedata[dy - 1].flags &= ~GRID_LINE_WRAPPED;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Free the history when it is cleared, based on a diff from Carlo Cannas.
2015-09-25 15:53:07 +00:00
memmove(&gd->linedata[dy], &gd->linedata[py],
ny * (sizeof *gd->linedata));
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
/*
* Wipe any lines that have been moved (without freeing them - they are
* still present).
*/
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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 (yy = py; yy < py + ny; yy++) {
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 (yy < dy || yy >= dy + ny)
grid_empty_line(gd, yy, 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
}
Reset wrapped flag when clearing or moving lines, GitHub issue 2215.
2020-06-04 21:41:31 +00:00
if (py != 0 && (py < dy || py >= dy + ny))
gd->linedata[py - 1].flags &= ~GRID_LINE_WRAPPED;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs displayed on one terminal be detached from one terminal and moved to another. ok deraadt pirofti
2009-06-01 22:58:49 +00:00
}
/* Move a group of cells. */
void
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
grid_move_cells(struct grid *gd, u_int dx, u_int px, u_int py, u_int nx,
u_int 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
{
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
struct grid_line *gl;
u_int xx;
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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 (nx == 0 || px == dx)
return;
Include source function name in grid_check_y logging.
2018-04-18 14:31:42 +00:00
if (grid_check_y(gd, __func__, py) != 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
return;
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
gl = &gd->linedata[py];
Import tmux, a terminal multiplexor allowing (among other things) a single terminal to be switched between several different windows and programs 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
grid_expand_line(gd, py, px + nx, 8);
grid_expand_line(gd, py, dx + nx, 8);
Free the history when it is cleared, based on a diff from Carlo Cannas.
2015-09-25 15:53:07 +00:00
memmove(&gl->celldata[dx], &gl->celldata[px],
nx * sizeof *gl->celldata);
If moving cells outside the current used count, update it.
2017-03-07 13:47:56 +00:00
if (dx + nx > gl->cellused)
gl->cellused = dx + 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
/* Wipe any cells that have been moved. */
for (xx = px; xx < px + nx; xx++) {
if (xx >= dx && xx < dx + nx)
continue;
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
grid_clear_cell(gd, xx, py, 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
}
}
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +00:00
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
/* Get ANSI foreground sequence. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static size_t
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
grid_string_cells_fg(const struct grid_cell *gc, int *values)
{
size_t n;
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;
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
n = 0;
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) {
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
values[n++] = 38;
values[n++] = 5;
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
values[n++] = gc->fg & 0xff;
} else if (gc->fg & COLOUR_FLAG_RGB) {
Add RGB escape sequences for capture-pane -e.
2016-01-31 09:57:09 +00:00
values[n++] = 38;
values[n++] = 2;
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);
values[n++] = r;
values[n++] = g;
values[n++] = b;
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
} else {
switch (gc->fg) {
Fix indentation of grid_string_cells_fg.
2015-09-02 17:12:07 +00:00
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
values[n++] = gc->fg + 30;
break;
case 8:
values[n++] = 39;
break;
case 90:
case 91:
case 92:
case 93:
case 94:
case 95:
case 96:
case 97:
values[n++] = gc->fg;
break;
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
}
}
return (n);
}
/* Get ANSI background sequence. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static size_t
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
grid_string_cells_bg(const struct grid_cell *gc, int *values)
{
size_t n;
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;
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
n = 0;
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) {
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
values[n++] = 48;
values[n++] = 5;
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
values[n++] = gc->bg & 0xff;
} else if (gc->bg & COLOUR_FLAG_RGB) {
Add RGB escape sequences for capture-pane -e.
2016-01-31 09:57:09 +00:00
values[n++] = 48;
values[n++] = 2;
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);
values[n++] = r;
values[n++] = g;
values[n++] = b;
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
} else {
switch (gc->bg) {
case 0:
case 1:
case 2:
case 3:
case 4:
case 5:
case 6:
case 7:
values[n++] = gc->bg + 40;
break;
case 8:
values[n++] = 49;
break;
AIX colours are always stored as 90-97, not 100-107. From Johannes Altmanninger.
2020-03-21 13:51:30 +00:00
case 90:
case 91:
case 92:
case 93:
case 94:
case 95:
case 96:
case 97:
values[n++] = gc->bg + 10;
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
break;
}
}
return (n);
}
Support underscore style with capture-pane -e, GitHub issue 2928.
2021-12-21 14:57:28 +00:00
/* Get underscore colour sequence. */
static size_t
grid_string_cells_us(const struct grid_cell *gc, int *values)
{
size_t n;
u_char r, g, b;
n = 0;
if (gc->us & COLOUR_FLAG_256) {
values[n++] = 58;
values[n++] = 5;
values[n++] = gc->us & 0xff;
} else if (gc->us & COLOUR_FLAG_RGB) {
values[n++] = 58;
values[n++] = 2;
colour_split_rgb(gc->us, &r, &g, &b);
values[n++] = r;
values[n++] = g;
values[n++] = b;
}
return (n);
}
/* Add on SGR code. */
static void
grid_string_cells_add_code(char *buf, size_t len, u_int n, int *s, int *newc,
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
int *oldc, size_t nnewc, size_t noldc, int flags)
Support underscore style with capture-pane -e, GitHub issue 2928.
2021-12-21 14:57:28 +00:00
{
u_int i;
char tmp[64];
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
int reset = (n != 0 && s[0] == 0);
if (nnewc == 0)
return; /* no code to add */
if (!reset &&
nnewc == noldc &&
memcmp(newc, oldc, nnewc * sizeof newc[0]) == 0)
return; /* no reset and colour unchanged */
if (reset && (newc[0] == 49 || newc[0] == 39))
return; /* reset and colour default */
if (flags & GRID_STRING_ESCAPE_SEQUENCES)
strlcat(buf, "\\033[", len);
else
strlcat(buf, "\033[", len);
for (i = 0; i < nnewc; i++) {
if (i + 1 < nnewc)
xsnprintf(tmp, sizeof tmp, "%d;", newc[i]);
Support underscore style with capture-pane -e, GitHub issue 2928.
2021-12-21 14:57:28 +00:00
else
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
xsnprintf(tmp, sizeof tmp, "%d", newc[i]);
strlcat(buf, tmp, len);
Support underscore style with capture-pane -e, GitHub issue 2928.
2021-12-21 14:57:28 +00:00
}
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
strlcat(buf, "m", len);
Support underscore style with capture-pane -e, GitHub issue 2928.
2021-12-21 14:57:28 +00:00
}
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
static int
grid_string_cells_add_hyperlink(char *buf, size_t len, const char *id,
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
const char *uri, int flags)
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
{
char *tmp;
if (strlen(uri) + strlen(id) + 17 >= len)
return (0);
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
if (flags & GRID_STRING_ESCAPE_SEQUENCES)
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
strlcat(buf, "\\033]8;", len);
else
strlcat(buf, "\033]8;", len);
if (*id != '\0') {
xasprintf(&tmp, "id=%s;", id);
strlcat(buf, tmp, len);
free(tmp);
} else
strlcat(buf, ";", len);
strlcat(buf, uri, len);
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
if (flags & GRID_STRING_ESCAPE_SEQUENCES)
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
strlcat(buf, "\\033\\\\", len);
else
strlcat(buf, "\033\\", len);
return (1);
}
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
/*
* Returns ANSI code to set particular attributes (colour, bold and so on)
Line length and spaces to tabs.
2017-05-16 12:57:26 +00:00
* given a current state.
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
*/
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
grid_string_cells_code(const struct grid_cell *lastgc,
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
const struct grid_cell *gc, char *buf, size_t len, int flags,
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
struct screen *sc, int *has_link)
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
{
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
int oldc[64], newc[64], s[128];
size_t noldc, nnewc, n, i;
u_int attr = gc->attr, lastattr = lastgc->attr;
char tmp[64];
const char *uri, *id;
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
static const struct {
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
u_int mask;
u_int code;
} attrs[] = {
{ GRID_ATTR_BRIGHT, 1 },
{ GRID_ATTR_DIM, 2 },
{ GRID_ATTR_ITALICS, 3 },
{ GRID_ATTR_UNDERSCORE, 4 },
{ GRID_ATTR_BLINK, 5 },
{ GRID_ATTR_REVERSE, 7 },
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
{ GRID_ATTR_HIDDEN, 8 },
Support for extended underline styles on terminals which offer them, enabled by adding the Smulx capability with terminal-overrides (add something like ',vte*:Smulx=\E[4\:%p1%dm'). GitHub issue 1492.
2018-10-18 07:57:57 +00:00
{ GRID_ATTR_STRIKETHROUGH, 9 },
{ GRID_ATTR_UNDERSCORE_2, 42 },
{ GRID_ATTR_UNDERSCORE_3, 43 },
{ GRID_ATTR_UNDERSCORE_4, 44 },
{ GRID_ATTR_UNDERSCORE_5, 45 },
Add support for overline (SGR 53), from Ricardo Banffy.
2019-05-13 20:10:23 +00:00
{ GRID_ATTR_OVERLINE, 53 },
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
};
n = 0;
/* If any attribute is removed, begin with 0. */
for (i = 0; i < nitems(attrs); i++) {
Support underscore style with capture-pane -e, GitHub issue 2928.
2021-12-21 14:57:28 +00:00
if (((~attr & attrs[i].mask) &&
(lastattr & attrs[i].mask)) ||
Use 8 for underscore colour defaults instead of 0 which is less confusing, and fix writing tge default colour. GitHub issue 3627.
2023-07-13 06:03:48 +00:00
(lastgc->us != 8 && gc->us == 8)) {
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
s[n++] = 0;
lastattr &= GRID_ATTR_CHARSET;
break;
}
}
/* For each attribute that is newly set, add its code. */
for (i = 0; i < nitems(attrs); i++) {
if ((attr & attrs[i].mask) && !(lastattr & attrs[i].mask))
s[n++] = attrs[i].code;
}
When we write out the grid including escape sequences, an SGR 0 needs to cause the colours to be written again. Also treat colours separately from attributes so that RGB colours will work.
2017-04-25 18:20:51 +00:00
/* Write the attributes. */
*buf = '\0';
if (n > 0) {
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
if (flags & GRID_STRING_ESCAPE_SEQUENCES)
When we write out the grid including escape sequences, an SGR 0 needs to cause the colours to be written again. Also treat colours separately from attributes so that RGB colours will work.
2017-04-25 18:20:51 +00:00
strlcat(buf, "\\033[", len);
else
strlcat(buf, "\033[", len);
for (i = 0; i < n; i++) {
Support for extended underline styles on terminals which offer them, enabled by adding the Smulx capability with terminal-overrides (add something like ',vte*:Smulx=\E[4\:%p1%dm'). GitHub issue 1492.
2018-10-18 07:57:57 +00:00
if (s[i] < 10)
When we write out the grid including escape sequences, an SGR 0 needs to cause the colours to be written again. Also treat colours separately from attributes so that RGB colours will work.
2017-04-25 18:20:51 +00:00
xsnprintf(tmp, sizeof tmp, "%d", s[i]);
Support for extended underline styles on terminals which offer them, enabled by adding the Smulx capability with terminal-overrides (add something like ',vte*:Smulx=\E[4\:%p1%dm'). GitHub issue 1492.
2018-10-18 07:57:57 +00:00
else {
xsnprintf(tmp, sizeof tmp, "%d:%d", s[i] / 10,
s[i] % 10);
}
When we write out the grid including escape sequences, an SGR 0 needs to cause the colours to be written again. Also treat colours separately from attributes so that RGB colours will work.
2017-04-25 18:20:51 +00:00
strlcat(buf, tmp, len);
Support for extended underline styles on terminals which offer them, enabled by adding the Smulx capability with terminal-overrides (add something like ',vte*:Smulx=\E[4\:%p1%dm'). GitHub issue 1492.
2018-10-18 07:57:57 +00:00
if (i + 1 < n)
strlcat(buf, ";", len);
When we write out the grid including escape sequences, an SGR 0 needs to cause the colours to be written again. Also treat colours separately from attributes so that RGB colours will work.
2017-04-25 18:20:51 +00:00
}
strlcat(buf, "m", len);
}
/* If the foreground colour changed, write its parameters. */
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
nnewc = grid_string_cells_fg(gc, newc);
noldc = grid_string_cells_fg(lastgc, oldc);
Support underscore style with capture-pane -e, GitHub issue 2928.
2021-12-21 14:57:28 +00:00
grid_string_cells_add_code(buf, len, n, s, newc, oldc, nnewc, noldc,
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
flags);
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
Fix some comments (c -> colour) and join unnecessary line splits.
2014-09-17 15:31:38 +00:00
/* If the background colour changed, append its parameters. */
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
nnewc = grid_string_cells_bg(gc, newc);
noldc = grid_string_cells_bg(lastgc, oldc);
Support underscore style with capture-pane -e, GitHub issue 2928.
2021-12-21 14:57:28 +00:00
grid_string_cells_add_code(buf, len, n, s, newc, oldc, nnewc, noldc,
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
flags);
Support underscore style with capture-pane -e, GitHub issue 2928.
2021-12-21 14:57:28 +00:00
/* If the underscore colour changed, append its parameters. */
nnewc = grid_string_cells_us(gc, newc);
noldc = grid_string_cells_us(lastgc, oldc);
grid_string_cells_add_code(buf, len, n, s, newc, oldc, nnewc, noldc,
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
flags);
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
/* Append shift in/shift out if needed. */
if ((attr & GRID_ATTR_CHARSET) && !(lastattr & GRID_ATTR_CHARSET)) {
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
if (flags & GRID_STRING_ESCAPE_SEQUENCES)
When we write out the grid including escape sequences, an SGR 0 needs to cause the colours to be written again. Also treat colours separately from attributes so that RGB colours will work.
2017-04-25 18:20:51 +00:00
strlcat(buf, "\\016", len); /* SO */
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
else
strlcat(buf, "\016", len); /* SO */
}
if (!(attr & GRID_ATTR_CHARSET) && (lastattr & GRID_ATTR_CHARSET)) {
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
if (flags & GRID_STRING_ESCAPE_SEQUENCES)
When we write out the grid including escape sequences, an SGR 0 needs to cause the colours to be written again. Also treat colours separately from attributes so that RGB colours will work.
2017-04-25 18:20:51 +00:00
strlcat(buf, "\\017", len); /* SI */
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
else
strlcat(buf, "\017", len); /* SI */
}
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
/* Add hyperlink if changed. */
if (sc != NULL && sc->hyperlinks != NULL && lastgc->link != gc->link) {
if (hyperlinks_get(sc->hyperlinks, gc->link, &uri, &id, NULL)) {
*has_link = grid_string_cells_add_hyperlink(buf, len,
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
id, uri, flags);
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
} else if (*has_link) {
grid_string_cells_add_hyperlink(buf, len, "", "",
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
flags);
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
*has_link = 0;
}
}
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
}
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +00:00
/* Convert cells into a string. */
char *
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
grid_string_cells(struct grid *gd, u_int px, u_int py, u_int nx,
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
struct grid_cell **lastgc, int flags, struct screen *s)
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +00:00
{
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
struct grid_cell gc;
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
static struct grid_cell lastgc1;
Various minor style and spacing nits.
2014-09-01 21:50:18 +00:00
const char *data;
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
char *buf, code[8192];
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
size_t len, off, size, codelen;
Change a few types to fix warnings, from Thomas Klausner.
2023-06-30 21:55:08 +00:00
u_int xx, end;
int has_link = 0;
Only include actual trailing spaces not unused cells with capturep -J, from George Nachman.
2013-10-10 11:49:29 +00:00
const struct grid_line *gl;
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +00:00
Allow lastgc to be NULL in grid_string_cells so find-window doesn't crash, problem reported by eugene everson.
2013-03-25 10:07:40 +00:00
if (lastgc != NULL && *lastgc == NULL) {
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
memcpy(&lastgc1, &grid_default_cell, sizeof lastgc1);
*lastgc = &lastgc1;
}
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +00:00
len = 128;
buf = xmalloc(len);
off = 0;
Only include actual trailing spaces not unused cells with capturep -J, from George Nachman.
2013-10-10 11:49:29 +00:00
gl = grid_peek_line(gd, py);
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
if (flags & GRID_STRING_EMPTY_CELLS)
end = gl->cellsize;
else
end = gl->cellused;
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +00:00
for (xx = px; xx < px + nx; xx++) {
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
if (gl == NULL || xx >= end)
Only include actual trailing spaces not unused cells with capturep -J, from George Nachman.
2013-10-10 11:49:29 +00:00
break;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
grid_get_cell(gd, xx, py, &gc);
if (gc.flags & GRID_FLAG_PADDING)
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +00:00
continue;
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
if (flags & GRID_STRING_WITH_SEQUENCES) {
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
grid_string_cells_code(*lastgc, &gc, code, sizeof code,
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
flags, s, &has_link);
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
codelen = strlen(code);
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
memcpy(*lastgc, &gc, sizeof **lastgc);
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
} else
codelen = 0;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
data = gc.data.data;
size = gc.data.size;
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
if ((flags & GRID_STRING_ESCAPE_SEQUENCES) &&
size == 1 &&
*data == '\\') {
Allow lastgc to be NULL in grid_string_cells so find-window doesn't crash, problem reported by eugene everson.
2013-03-25 10:07:40 +00:00
data = "\\\\";
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
size = 2;
}
while (len < off + size + codelen + 1) {
Add xreallocarray and remove nmemb argument from xrealloc.
2014-10-08 17:35:58 +00:00
buf = xreallocarray(buf, 2, len);
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
len *= 2;
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +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
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
if (codelen != 0) {
memcpy(buf + off, code, codelen);
off += codelen;
}
memcpy(buf + off, data, size);
off += size;
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +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
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
if (has_link) {
grid_string_cells_add_hyperlink(code, sizeof code, "", "",
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
flags);
Support hyperlinks with capture-pane -e and add a mouse_hyperlink format, GitHub issue 3247 from Jeff Chiang.
2022-07-06 07:36:36 +00:00
codelen = strlen(code);
while (len < off + size + codelen + 1) {
buf = xreallocarray(buf, 2, len);
len *= 2;
}
memcpy(buf + off, code, codelen);
off += codelen;
}
Add a -T flag to capture-pane to stop at the last used cell instead of the full width. Restore the previous behaviour by making it default to off unless -J is used (the only time it matters). Fixes mosh unit tests; GitHub issue 3339.
2022-09-28 07:55:29 +00:00
if (flags & GRID_STRING_TRIM_SPACES) {
Allow lastgc to be NULL in grid_string_cells so find-window doesn't crash, problem reported by eugene everson.
2013-03-25 10:07:40 +00:00
while (off > 0 && buf[off - 1] == ' ')
off--;
Style and comment fixes from Tiago Cunha.
2014-01-09 13:58:06 +00:00
}
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +00:00
buf[off] = '\0';
Add -C and -J to capture pane to escape control sequences and to join wrapped line, based on a diff from George Nachman.
2013-03-22 15:56:11 +00:00
Add a dedicated function to convert a line into a string and use it to simplify the search window function.
2009-06-24 22:04:18 +00:00
return (buf);
}
Support "alternate screen" mode (terminfo smcup/rmcup) typically used by full screen interactive programs to preserve the screen contents. When activated, it saves a copy of the visible grid and disables scrolling into and resizing out of the history; when deactivated the visible data is restored and the history reenabled.
2009-07-13 10:43:52 +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
/*
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
* Duplicate a set of lines between two grids. Both source and destination
* should be big enough.
Support "alternate screen" mode (terminfo smcup/rmcup) typically used by full screen interactive programs to preserve the screen contents. When activated, it saves a copy of the visible grid and disables scrolling into and resizing out of the history; when deactivated the visible data is restored and the history reenabled.
2009-07-13 10:43:52 +00:00
*/
void
Trivial style and spacing nits.
2013-10-10 12:01:14 +00:00
grid_duplicate_lines(struct grid *dst, u_int dy, struct grid *src, u_int sy,
u_int ny)
Support "alternate screen" mode (terminfo smcup/rmcup) typically used by full screen interactive programs to preserve the screen contents. When activated, it saves a copy of the visible grid and disables scrolling into and resizing out of the history; when deactivated the visible data is restored and the history reenabled.
2009-07-13 10:43:52 +00:00
{
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
struct grid_line *dstl, *srcl;
u_int yy;
Support "alternate screen" mode (terminfo smcup/rmcup) typically used by full screen interactive programs to preserve the screen contents. When activated, it saves a copy of the visible grid and disables scrolling into and resizing out of the history; when deactivated the visible data is restored and the history reenabled.
2009-07-13 10:43:52 +00:00
if (dy + ny > dst->hsize + dst->sy)
ny = dst->hsize + dst->sy - dy;
if (sy + ny > src->hsize + src->sy)
ny = src->hsize + src->sy - sy;
Instead of overloading the line clear function to mean free if background is default (8), introduce an explicit free function and use it where a free alone is needed. Likewise, use memmove directly rather than grid_move_lines where it makes sense. Based on a memory leak fix by Dan Aloni in GitHub issue 1051.
2017-08-30 18:13:47 +00:00
grid_free_lines(dst, dy, ny);
Support "alternate screen" mode (terminfo smcup/rmcup) typically used by full screen interactive programs to preserve the screen contents. When activated, it saves a copy of the visible grid and disables scrolling into and resizing out of the history; when deactivated the visible data is restored and the history reenabled.
2009-07-13 10:43:52 +00:00
for (yy = 0; yy < ny; yy++) {
Use the right source and destination lines in grid_duplicate_lines.
2009-08-10 17:59:59 +00:00
srcl = &src->linedata[sy];
dstl = &dst->linedata[dy];
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
memcpy(dstl, srcl, sizeof *dstl);
if (srcl->cellsize != 0) {
use reallocarray instead of calloc; avoid the zero before infill ok nicm
2015-04-23 07:45:50 +00:00
dstl->celldata = xreallocarray(NULL,
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
srcl->cellsize, sizeof *dstl->celldata);
memcpy(dstl->celldata, srcl->celldata,
srcl->cellsize * sizeof *dstl->celldata);
In grid_duplicate_lines, if the line is empty (cellsize == 0) then clear the destination celldata pointer rather than leaving a stale copy of the source pointer (which may later be freed). Fixes a crash found by Kuang-che Wu.
2015-08-24 22:49:13 +00:00
} else
dstl->celldata = NULL;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
if (srcl->extdsize != 0) {
dstl->extdsize = srcl->extdsize;
dstl->extddata = xreallocarray(NULL, dstl->extdsize,
sizeof *dstl->extddata);
memcpy(dstl->extddata, srcl->extddata, dstl->extdsize *
sizeof *dstl->extddata);
Send Unicode directional isolate characters around horizontal pane borders if the terminal support UTF-8 and an extension terminfo(5) capability "Bidi" is present. On terminals with BiDi support (ie, VTE) this seems to be enough to display right-to-left text acceptably enough to be usable (with some caveats about the mouse position). Requested by and with help from Mahmoud Elagdar in GitHub issue 2425.
2021-02-05 12:29:18 +00:00
} else
dstl->extddata = NULL;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
Change the way the grid is stored, previously it was: - a two-dimensional array of cells; - a two-dimensional array of utf8 data; - an array of line lengths. Now it is a single array of a new struct grid_line each of which represents a line and containts the length and an array of cells and an array of utf8 data. This will make it easier to add additional per-line members, such as flags.
2009-08-08 13:29:27 +00:00
sy++;
dy++;
Support "alternate screen" mode (terminfo smcup/rmcup) typically used by full screen interactive programs to preserve the screen contents. When activated, it saves a copy of the visible grid and disables scrolling into and resizing out of the history; when deactivated the visible data is restored and the history reenabled.
2009-07-13 10:43:52 +00:00
}
}
Automatically reflow wrapped lines when a pane is resized, requested by many over the years and finally implemented by Richard Woodbury.
2013-02-05 11:08:59 +00:00
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
/* Mark line as dead. */
static void
grid_reflow_dead(struct grid_line *gl)
{
memset(gl, 0, sizeof *gl);
gl->flags = GRID_LINE_DEAD;
}
/* Add lines, return the first new one. */
static struct grid_line *
grid_reflow_add(struct grid *gd, u_int n)
{
struct grid_line *gl;
u_int sy = gd->sy + n;
gd->linedata = xreallocarray(gd->linedata, sy, sizeof *gd->linedata);
gl = &gd->linedata[gd->sy];
memset(gl, 0, n * (sizeof *gl));
gd->sy = sy;
return (gl);
}
/* Move a line across. */
static struct grid_line *
grid_reflow_move(struct grid *gd, struct grid_line *from)
{
struct grid_line *to;
to = grid_reflow_add(gd, 1);
memcpy(to, from, sizeof *to);
grid_reflow_dead(from);
return (to);
}
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/* Join line below onto this one. */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
grid_reflow_join(struct grid *target, struct grid *gd, u_int sx, u_int yy,
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
u_int width, int already)
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
{
Fix some compiler warnings; from Thomas Adam.
2018-06-11 11:14:10 +00:00
struct grid_line *gl, *from = NULL;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
struct grid_cell gc;
Fix some compiler warnings; from Thomas Adam.
2018-06-11 11:14:10 +00:00
u_int lines, left, i, to, line, want = 0;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
u_int at;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
int wrapped = 1;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
/*
* Add a new target line.
*/
if (!already) {
to = target->sy;
gl = grid_reflow_move(target, &gd->linedata[yy]);
} else {
to = target->sy - 1;
gl = &target->linedata[to];
}
at = gl->cellused;
/*
* Loop until no more to consume or the target line is full.
*/
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
lines = 0;
for (;;) {
/*
* If this is now the last line, there is nothing more to be
* done.
*/
Increment the lines counter when skipping a line to avoid an infinite loop, and fix a check to avoid a potential out-of-bounds access. Problem reported by Yuxiang Qin and tracked down by Karl Beldan; GitHub issue 1352. Also a man page fix request by jmc@.
2018-06-03 10:17:30 +00:00
if (yy + 1 + lines == gd->hsize + gd->sy)
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
break;
line = yy + 1 + lines;
/* If the next line is empty, skip it. */
if (~gd->linedata[line].flags & GRID_LINE_WRAPPED)
wrapped = 0;
if (gd->linedata[line].cellused == 0) {
if (!wrapped)
break;
Increment the lines counter when skipping a line to avoid an infinite loop, and fix a check to avoid a potential out-of-bounds access. Problem reported by Yuxiang Qin and tracked down by Karl Beldan; GitHub issue 1352. Also a man page fix request by jmc@.
2018-06-03 10:17:30 +00:00
lines++;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
continue;
}
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/*
* Is the destination line now full? Copy the first character
* separately because we need to leave "from" set to the last
* line if this line is full.
*/
grid_get_cell1(&gd->linedata[line], 0, &gc);
if (width + gc.data.width > sx)
break;
width += gc.data.width;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
grid_set_cell(target, at, to, &gc);
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
at++;
/* Join as much more as possible onto the current line. */
from = &gd->linedata[line];
for (want = 1; want < from->cellused; want++) {
grid_get_cell1(from, want, &gc);
if (width + gc.data.width > sx)
break;
width += gc.data.width;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
grid_set_cell(target, at, to, &gc);
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
at++;
}
lines++;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/*
* If this line wasn't wrapped or we didn't consume the entire
* line, don't try to join any further lines.
*/
if (!wrapped || want != from->cellused || width == sx)
break;
}
if (lines == 0)
return;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/*
* If we didn't consume the entire final line, then remove what we did
* consume. If we consumed the entire line and it wasn't wrapped,
* remove the wrap flag from this line.
*/
left = from->cellused - want;
if (left != 0) {
grid_move_cells(gd, 0, want, yy + lines, left, 8);
from->cellsize = from->cellused = left;
lines--;
} else if (!wrapped)
gl->flags &= ~GRID_LINE_WRAPPED;
/* Remove the lines that were completely consumed. */
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
for (i = yy + 1; i < yy + 1 + lines; i++) {
free(gd->linedata[i].celldata);
free(gd->linedata[i].extddata);
grid_reflow_dead(&gd->linedata[i]);
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
}
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
/* Adjust scroll position. */
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
if (gd->hscrolled > to + lines)
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
gd->hscrolled -= lines;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
else if (gd->hscrolled > to)
gd->hscrolled = to;
Long overdue change to the way we store cells in the grid: now, instead of storing a full grid_cell with UTF-8 data and everything, store a new type grid_cell_entry. This can either be the cell itself (for ASCII cells), or an offset into an extended array (per line) for UTF-8 data. This avoid a large (8 byte) overhead on non-UTF-8 cells (by far the majority for most users) without the complexity of the shadow array we had before. Grid memory without any UTF-8 is about half. The disadvantage that cells can no longer be modified in place and need to be copied out of the grid and back but it turned out to be lot less complicated than I expected.
2015-11-13 08:09:28 +00:00
}
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/* Split this line into several new ones */
Loads more static, except for cmd-*.c and window-*.c.
2016-10-10 21:29:23 +00:00
static void
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
grid_reflow_split(struct grid *target, struct grid *gd, u_int sx, u_int yy,
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
u_int at)
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
{
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
struct grid_line *gl = &gd->linedata[yy], *first;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
struct grid_cell gc;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
u_int line, lines, width, i, xx;
u_int used = gl->cellused;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
int flags = gl->flags;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
/* How many lines do we need to insert? We know we need at least two. */
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
if (~gl->flags & GRID_LINE_EXTENDED)
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
lines = 1 + (gl->cellused - 1) / sx;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
else {
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
lines = 2;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
width = 0;
for (i = at; i < used; i++) {
grid_get_cell1(gl, i, &gc);
if (width + gc.data.width > sx) {
lines++;
width = 0;
}
width += gc.data.width;
}
}
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/* Insert new lines. */
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
line = target->sy + 1;
first = grid_reflow_add(target, lines);
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/* Copy sections from the original line. */
width = 0;
xx = 0;
for (i = at; i < used; i++) {
grid_get_cell1(gl, i, &gc);
if (width + gc.data.width > sx) {
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
target->linedata[line].flags |= GRID_LINE_WRAPPED;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
line++;
width = 0;
xx = 0;
}
width += gc.data.width;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
grid_set_cell(target, xx, line, &gc);
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
xx++;
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
}
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
if (flags & GRID_LINE_WRAPPED)
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
target->linedata[line].flags |= GRID_LINE_WRAPPED;
/* Move the remainder of the original line. */
gl->cellsize = gl->cellused = at;
gl->flags |= GRID_LINE_WRAPPED;
memcpy(first, gl, sizeof *first);
grid_reflow_dead(gl);
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
/* Adjust the scroll position. */
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
if (yy <= gd->hscrolled)
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
gd->hscrolled += lines - 1;
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/*
* If the original line had the wrapped flag and there is still space
* in the last new line, try to join with the next lines.
*/
if (width < sx && (flags & GRID_LINE_WRAPPED))
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
grid_reflow_join(target, gd, sx, yy, width, 1);
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
}
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/* Reflow lines on grid to new width. */
void
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
grid_reflow(struct grid *gd, u_int sx)
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
{
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
struct grid *target;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
struct grid_line *gl;
struct grid_cell gc;
Do not force line width to grid width because it may need to be larger to accomodate a wide character. GitHub issue 2336.
2020-08-07 07:02:57 +00:00
u_int yy, width, i, at;
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/*
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
* Create a destination grid. This is just used as a container for the
* line data and may not be fully valid.
*/
target = grid_create(gd->sx, 0, 0);
/*
* Loop over each source line.
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
*/
for (yy = 0; yy < gd->hsize + gd->sy; yy++) {
gl = &gd->linedata[yy];
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
if (gl->flags & GRID_LINE_DEAD)
continue;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
/*
Do not force line width to grid width because it may need to be larger to accomodate a wide character. GitHub issue 2336.
2020-08-07 07:02:57 +00:00
* Work out the width of this line. at is the point at which
* the available width is hit, and width is the full line
* width.
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
*/
Do not force line width to grid width because it may need to be larger to accomodate a wide character. GitHub issue 2336.
2020-08-07 07:02:57 +00:00
at = width = 0;
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
if (~gl->flags & GRID_LINE_EXTENDED) {
width = gl->cellused;
if (width > sx)
at = sx;
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
else
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
at = width;
Rework reflow code so it does not do so much allocation which should be faster with large histories.
2013-03-21 16:12:10 +00:00
} else {
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
for (i = 0; i < gl->cellused; i++) {
grid_get_cell1(gl, i, &gc);
if (at == 0 && width + gc.data.width > sx)
at = i;
width += gc.data.width;
}
}
/*
Do not force line width to grid width because it may need to be larger to accomodate a wide character. GitHub issue 2336.
2020-08-07 07:02:57 +00:00
* If the line is exactly right, just move it across
* unchanged.
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
*/
Do not force line width to grid width because it may need to be larger to accomodate a wide character. GitHub issue 2336.
2020-08-07 07:02:57 +00:00
if (width == sx) {
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
grid_reflow_move(target, gl);
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
continue;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
}
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/*
* If the line is too big, it needs to be split, whether or not
* it was previously wrapped.
*/
if (width > sx) {
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
grid_reflow_split(target, gd, sx, yy, at);
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
continue;
Automatically reflow wrapped lines when a pane is resized, requested by many over the years and finally implemented by Richard Woodbury.
2013-02-05 11:08:59 +00:00
}
Remember the number of lines scrolled into the history (versus cleared into the history) and when resizing only use scrolled lines and not cleared lines (which are probably not intended to reappear). From Chaoren Lin.
2016-09-02 20:57:20 +00:00
Completely rewrite the reflow code to correctly handle double width characters (previously they were not accounted for).
2017-11-15 19:21:24 +00:00
/*
* If the line was previously wrapped, join as much as possible
* of the next line.
*/
if (gl->flags & GRID_LINE_WRAPPED)
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
grid_reflow_join(target, gd, sx, yy, width, 0);
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
else
grid_reflow_move(target, gl);
Automatically reflow wrapped lines when a pane is resized, requested by many over the years and finally implemented by Richard Woodbury.
2013-02-05 11:08:59 +00:00
}
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
/*
* Replace the old grid with the new.
*/
if (target->sy < gd->sy)
grid_reflow_add(target, gd->sy - target->sy);
gd->hsize = target->sy - gd->sy;
Restore a check to stop scrolled lines becoming larger than total lines, fixes a crash reported by Thomas Sattler.
2019-04-01 19:33:38 +00:00
if (gd->hscrolled > gd->hsize)
gd->hscrolled = gd->hsize;
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
free(gd->linedata);
gd->linedata = target->linedata;
free(target);
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
}
Reflowing the grid in-place involved way too much memmove() for a big performance cost with a large history. Instead change back to using a second grid and copying modified lines over which is much faster (this doesn't revert to the old code however which didn't support UTF-8 properly). GitHub issue 1249.
2018-02-16 09:51:41 +00:00
Store and restore cursor across reflow by working out a position based on unwrapped lines, rather than a grid offset. Fixes problems reported by Thomas Sattler and Paul de Weerd.
2019-04-02 08:45:32 +00:00
/* Convert to position based on wrapped lines. */
void
grid_wrap_position(struct grid *gd, u_int px, u_int py, u_int *wx, u_int *wy)
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
{
Store and restore cursor across reflow by working out a position based on unwrapped lines, rather than a grid offset. Fixes problems reported by Thomas Sattler and Paul de Weerd.
2019-04-02 08:45:32 +00:00
u_int ax = 0, ay = 0, yy;
for (yy = 0; yy < py; yy++) {
if (gd->linedata[yy].flags & GRID_LINE_WRAPPED)
ax += gd->linedata[yy].cellused;
else {
ax = 0;
ay++;
}
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
}
Store and restore cursor across reflow by working out a position based on unwrapped lines, rather than a grid offset. Fixes problems reported by Thomas Sattler and Paul de Weerd.
2019-04-02 08:45:32 +00:00
if (px >= gd->linedata[yy].cellused)
ax = UINT_MAX;
else
ax += px;
*wx = ax;
*wy = ay;
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
}
Store and restore cursor across reflow by working out a position based on unwrapped lines, rather than a grid offset. Fixes problems reported by Thomas Sattler and Paul de Weerd.
2019-04-02 08:45:32 +00:00
/* Convert position based on wrapped lines back. */
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
void
Store and restore cursor across reflow by working out a position based on unwrapped lines, rather than a grid offset. Fixes problems reported by Thomas Sattler and Paul de Weerd.
2019-04-02 08:45:32 +00:00
grid_unwrap_position(struct grid *gd, u_int *px, u_int *py, u_int wx, u_int wy)
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
{
Some more, and use of wp->window before wp NULL check in format.c.
2020-04-09 13:53:50 +00:00
u_int yy, ay = 0;
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
for (yy = 0; yy < gd->hsize + gd->sy - 1; yy++) {
Store and restore cursor across reflow by working out a position based on unwrapped lines, rather than a grid offset. Fixes problems reported by Thomas Sattler and Paul de Weerd.
2019-04-02 08:45:32 +00:00
if (ay == wy)
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
break;
Some more, and use of wp->window before wp NULL check in format.c.
2020-04-09 13:53:50 +00:00
if (~gd->linedata[yy].flags & GRID_LINE_WRAPPED)
Store and restore cursor across reflow by working out a position based on unwrapped lines, rather than a grid offset. Fixes problems reported by Thomas Sattler and Paul de Weerd.
2019-04-02 08:45:32 +00:00
ay++;
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
}
Store and restore cursor across reflow by working out a position based on unwrapped lines, rather than a grid offset. Fixes problems reported by Thomas Sattler and Paul de Weerd.
2019-04-02 08:45:32 +00:00
/*
* yy is now 0 on the unwrapped line which contains wx. Walk forwards
* until we find the end or the line now containing wx.
*/
if (wx == UINT_MAX) {
while (gd->linedata[yy].flags & GRID_LINE_WRAPPED)
yy++;
wx = gd->linedata[yy].cellused;
} else {
while (gd->linedata[yy].flags & GRID_LINE_WRAPPED) {
if (wx < gd->linedata[yy].cellused)
break;
wx -= gd->linedata[yy].cellused;
yy++;
}
}
*px = wx;
Improve cursor positioning after reflow by storing the position as an offset into the entire history before reflow and restoring it aftewards.
2019-03-20 19:19:11 +00:00
*py = yy;
Automatically reflow wrapped lines when a pane is resized, requested by many over the years and finally implemented by Richard Woodbury.
2013-02-05 11:08:59 +00:00
}
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
/* Get length of line. */
u_int
grid_line_length(struct grid *gd, u_int py)
{
struct grid_cell gc;
u_int px;
px = grid_get_line(gd, py)->cellsize;
if (px > gd->sx)
px = gd->sx;
while (px > 0) {
grid_get_cell(gd, px - 1, py, &gc);
Add screen write flags instead of individual bits and fix line length calculation with padding.
2020-05-16 16:22:01 +00:00
if ((gc.flags & GRID_FLAG_PADDING) ||
gc.data.size != 1 ||
*gc.data.data != ' ')
Add formats for word and line under the mouse and use them to add some items to the pane menu.
2019-05-26 17:34:45 +00:00
break;
px--;
}
return (px);
}
Reference in New Issue Copy Permalink