mirrors/foot
1
0
Fork 0
mirror of https://codeberg.org/dnkl/foot.git synced 2026-02-05 04:06:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions
foot/terminal.h

748 lines
20 KiB
C
Raw Normal View History

wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
#pragma once
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
#include <wchar.h>
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
wip: initial input handling
2019-06-19 10:04:47 +02:00
#include <threads.h>
wip: initial multithreaded renderer
2019-07-29 20:13:26 +02:00
#include <semaphore.h>
wip: initial input handling
2019-06-19 10:04:47 +02:00
wip: grapheme shaping
2020-08-20 19:25:35 +02:00
#if defined(FOOT_GRAPHEME_CLUSTERING)
#include <utf8proc.h>
#endif
fcft: use fcft instead of local copy of font.c/font.h
2019-12-01 13:43:51 +01:00
#include <tllist.h>
fcft: include <fcft/fcft.h>, and use fcft/stride.h instead of local copy
2019-12-01 14:03:24 +01:00
#include <fcft/fcft.h>
fcft: use fcft instead of local copy of font.c/font.h
2019-12-01 13:43:51 +01:00
terminal: implement term_init() and term_destroy()
2019-10-28 18:25:19 +01:00
//#include "config.h"
composed: store compose chains in a binary search tree The previous implementation stored compose chains in a dynamically allocated array. Adding a chain was easy: resize the array and append the new chain at the end. Looking up a compose chain given a compose chain key/index was also easy: just index into the array. However, searching for a pre-existing chain given a codepoint sequence was very slow. Since the array wasn’t sorted, we typically had to scan through the entire array, just to realize that there is no pre-existing chain, and that we need to add a new one. Since this happens for *each* codepoint in a grapheme cluster, things quickly became really slow. Things were ok:ish as long as the compose chain struct was small, as that made it possible to hold all the chains in the cache. Once the number of chains reached a certain point, or when we were forced to bump maximum number of allowed codepoints in a chain, we started thrashing the cache and things got much much worse. So what can we do? We can’t sort the array, because a) that would invalidate all existing chain keys in the grid (and iterating the entire scrollback and updating compose keys is *not* an option). b) inserting a chain becomes slow as we need to first find _where_ to insert it, and then memmove() the rest of the array. This patch uses a binary search tree to store the chains instead of a simple array. The tree is sorted on a “key”, which is the XOR of all codepoints, truncated to the CELL_COMB_CHARS_HI-CELL_COMB_CHARS_LO range. The grid now stores CELL_COMB_CHARS_LO+key, instead of CELL_COMB_CHARS_LO+index. Since the key is truncated, collisions may occur. This is handled by incrementing the key by 1. Lookup is of course slower than before, O(log n) instead of O(1). Insertion is slightly slower as well: technically it’s O(log n) instead of O(1). However, we also need to take into account the re-allocating the array will occasionally force a full copy of the array when it cannot simply be growed. But finding a pre-existing chain is now *much* faster: O(log n) instead of O(n). In most cases, the first lookup will either succeed (return a true match), or fail (return NULL). However, since key collisions are possible, it may also return false matches. This means we need to verify the contents of the chain before deciding to use it instead of inserting a new chain. But remember that this comparison was being done for each and every chain in the previous implementation. With lookups being much faster, and in particular, no longer requiring us to check the chain contents for every singlec chain, we can now use a dynamically allocated ‘chars’ array in the chain. This was previously a hardcoded array of 10 chars. Using a dynamic allocated array means looking in the array is slower, since we now need two loads: one to load the pointer, and a second to load _from_ the pointer. As a result, the base size of a compose chain (i.e. an “empty” chain) has now been reduced from 48 bytes to 32. A chain with two codepoints is 40 bytes. This means we have up to 4 codepoints while still using less, or the same amount, of memory as before. Furthermore, the Unicode random test (i.e. write random “unicode” chars) is now **faster** than current master (i.e. before text-shaping support was added), **with** test-shaping enabled. With text-shaping disabled, we’re _even_ faster.
2021-06-24 13:17:07 +02:00
#include "composed.h"
Print stack trace on assert() failure or when calling fatal_error() Note: this uses the __sanitizer_print_stack_trace() function from the AddressSanitizer runtime, so it only works when AddressSanitizer is in use.
2021-01-15 20:39:45 +00:00
#include "debug.h"
terminal: implement term_init() and term_destroy()
2019-10-28 18:25:19 +01:00
#include "fdm.h"
config: handle allocation failure explicitly
2020-08-04 23:28:16 +01:00
#include "macros.h"
term: don't double fork new terminal windows Instead, register their PIDs with the new reaper module and let it handle them.
2020-05-21 20:17:29 +02:00
#include "reaper.h"
shm: refactor: move away from a single, global, buffer list Up until now, *all* buffers have been tracked in a single, global buffer list. We've used 'cookies' to separate buffers from different contexts (so that shm_get_buffer() doesn't try to re-use e.g. a search-box buffer for the main grid). This patch refactors this, and completely removes the global list. Instead of cookies, we now use 'chains'. A chain tracks both the properties to apply to newly created buffers (scrollable, number of pixman instances to instantiate etc), as well as the instantiated buffers themselves. This means there's strictly speaking not much use for shm_fini() anymore, since its up to the chain owner to call shm_chain_free(), which will also purge all buffers. However, since purging a buffer may be deferred, if the buffer is owned by the compositor at the time of the call to shm_purge() or shm_chain_free(), we still keep a global 'deferred' list, on to which deferred buffers are pushed. shm_fini() iterates this list and destroys the buffers _even_ if they are still owned by the compositor. This only happens at program termination, and not when destroying a terminal instance. I.e. closing a window in a “foot --server” does *not* trigger this. Each terminal instatiates a number of chains, and these chains are destroyed when the terminal instance is destroyed. Note that some buffers may be put on the deferred list, as mentioned above.
2021-07-16 16:48:49 +02:00
#include "shm.h"
wayland: move wayland struct definitions to a separate file
2019-10-27 13:06:39 +01:00
#include "wayland.h"
Use a 'damage' list to communicate what needs to be updated Instead of having each cell in the grid track it's own dirtiness, grid operations now append "damage" to a list. This list is consumed every time we render the grid. This allows us to special case some operations, like erase (and in the future, scroll).
2019-06-19 14:17:43 +02:00
terminal: use floats instead of double for colors We don't need the full resolution a double gives us. Using floats reduces the size of cells greatly, which improves cache usage.
2019-07-10 18:48:46 +02:00
/*
* Note: we want the cells to be as small as possible. Larger cells
* means fewer scrollback lines (or performance drops due to cache
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
* misses)
*
* Note that the members are laid out optimized for x86
*/
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
struct attributes {
term: attributes struct: use ‘bool’ instead of ‘uint32_t’ for 1-bit members
2021-04-17 22:11:14 +02:00
bool bold:1;
bool dim:1;
bool italic:1;
bool underline:1;
bool strikethrough:1;
bool blink:1;
bool conceal:1;
bool reverse:1;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
uint32_t fg:24;
terminal: use floats instead of double for colors We don't need the full resolution a double gives us. Using floats reduces the size of cells greatly, which improves cache usage.
2019-07-10 18:48:46 +02:00
term: attributes struct: use ‘bool’ instead of ‘uint32_t’ for 1-bit members
2021-04-17 22:11:14 +02:00
bool clean:1;
render: Allow cells to bleed into their neighbor This patch adds a `confined` flag to each cell to track if the last rendered glyph bled into it's right neighbor. To keep things simple, bleeding into any other neighbor cell than the immediate right one is not allowed. This should cover most use cases. Before rendering a row we now do a prepass and mark all cells unclean that are affected by a bleeding neighbor. If there are consecutive bleeding cells, the whole group must be re-rendered even if only a single cell has changed. The patch also deprecates both old overflowing glyph options *allow-overflowing-double-width-glyphs* and *pua-double-width* in favor of a single new one named *overflowing-glyphs*.
2021-06-15 11:45:27 +02:00
bool confined:1;
term: attributes struct: use ‘bool’ instead of ‘uint32_t’ for 1-bit members
2021-04-17 22:11:14 +02:00
bool have_fg:1;
bool have_bg:1;
selection: update: don't dirty cells that don't change state Previously when updating a selection, we would unmark *all* cells in the old selection, and then mark all cells in the new selection. This caused *all* cells to be dirtied and thus re-rendered. Avoid this, by adding a temporary state to the cells' selected state. Before unmarking the old selection, pre-mark the new selection using a temporary state. When unmarking the old selection, ignore cells in this temporary state. When marking the new selection, ignore cells in this temporary state (except clearing the temporary state).
2020-01-06 11:56:18 +01:00
uint32_t selected:2;
term: attributes struct: use ‘bool’ instead of ‘uint32_t’ for 1-bit members
2021-04-17 22:11:14 +02:00
bool url:1;
render: Allow cells to bleed into their neighbor This patch adds a `confined` flag to each cell to track if the last rendered glyph bled into it's right neighbor. To keep things simple, bleeding into any other neighbor cell than the immediate right one is not allowed. This should cover most use cases. Before rendering a row we now do a prepass and mark all cells unclean that are affected by a bleeding neighbor. If there are consecutive bleeding cells, the whole group must be re-rendered even if only a single cell has changed. The patch also deprecates both old overflowing glyph options *allow-overflowing-double-width-glyphs* and *pua-double-width* in favor of a single new one named *overflowing-glyphs*.
2021-06-15 11:45:27 +02:00
uint32_t reserved:1;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
uint32_t bg:24;
};
term: attributes struct: use ‘bool’ instead of ‘uint32_t’ for 1-bit members
2021-04-17 22:11:14 +02:00
static_assert(sizeof(struct attributes) == 8, "VT attribute struct too large");
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
term: CELL_COMB_CHARS chars are keys, not indices -> more range is better Bump the available key range to 30 bits. This helps reduce key collisions when handling a large amount of grapheme clusters.
2021-06-24 19:15:53 +02:00
/* Last valid Unicode code point is 0x0010FFFFul */
#define CELL_COMB_CHARS_LO 0x00200000ul
#define CELL_COMB_CHARS_HI (CELL_COMB_CHARS_LO + 0x3fffffff)
#define CELL_SPACER (CELL_COMB_CHARS_HI + 1)
term: print: write special value CELL_MULT_COL_SPACER to extra cells When printing a multi-column character, write CELL_MULT_COL_SPACER instead of '0' to both padding cells (when character doesn't fit at the end of the line), and to the cells following the actual character.
2020-07-14 16:49:11 +02:00
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
struct cell {
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
wchar_t wc;
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
struct attributes attrs;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
};
static_assert(sizeof(struct cell) == 12, "bad size");
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
scroll-region: don't clear damage queue when changing scroll region Vim, for example, changes the scroll region every time you scroll a single line. Thus, resetting the damage queue is slow. This reworks the damage handling of scroll updates: * Split damage queue into two: one for scroll operations and one for update/erase operations. * Don't separate update/erase operations inside/outside the scroll region * Store the current scroll region in the scroll damage operation. This allows us to stack multiple scroll operations with different scroll regions. * When updating update/erase operations after a scroll operation, split the update/erase operations if necessary (the current scroll operation may have a scroll region different from before, thus forcing us to split existing update/erase operations. * The renderer no longer erases after a scroll. The scroll operation also adds an erase operation. This also means that erase operation are subject to adjustments by later scroll operations.
2019-06-25 20:11:08 +02:00
struct scroll_region {
int start;
int end;
};
wip: grid is now represented as a grid, not a linear array The grid is now represented with an array of row *pointers*. Each row contains an array of cells (the row's columns). The main point of having row pointers is we can now move rows around almost for free. This is useful when scrolling with scroll margins for example, where we previously had to copy the lines in the margins. Now it's just a matter of swapping two pointers.
2019-07-08 13:57:31 +02:00
struct coord {
terminal: move cursor from grid to terminal
2019-06-29 21:15:32 +02:00
int col;
wip: grid is now represented as a grid, not a linear array The grid is now represented with an array of row *pointers*. Each row contains an array of cells (the row's columns). The main point of having row pointers is we can now move rows around almost for free. This is useful when scrolling with scroll margins for example, where we previously had to copy the lines in the margins. Now it's just a matter of swapping two pointers.
2019-07-08 13:57:31 +02:00
int row;
terminal: move cursor from grid to terminal
2019-06-29 21:15:32 +02:00
};
term: add struct cursor
2019-11-17 09:44:31 +01:00
struct cursor {
struct coord point;
term: move lcf flag into 'cursor' struct
2019-11-17 09:46:20 +01:00
bool lcf;
term: add struct cursor
2019-11-17 09:44:31 +01:00
};
scrollback: regression: fix rendering of scrollback diffs less than a screen When doing "small" scrolls (typically done via mouse wheel or similar), we render the scrolling by emitting a "scroll damage". A recent commit changed how scroll damage is rendered; only when the view is at the bottom ("following" the screen output) do we render the damage. To fix this, add a new type of scroll damage, SCROLL_DAMAGE_IN_VIEW and SCROLL_DAMAGE_REVERSE_IN_VIEW. These signal to the renderer that it should always render the damage.
2019-10-29 21:09:37 +01:00
enum damage_type {DAMAGE_SCROLL, DAMAGE_SCROLL_REVERSE,
DAMAGE_SCROLL_IN_VIEW, DAMAGE_SCROLL_REVERSE_IN_VIEW};
Use a 'damage' list to communicate what needs to be updated Instead of having each cell in the grid track it's own dirtiness, grid operations now append "damage" to a list. This list is consumed every time we render the grid. This allows us to special case some operations, like erase (and in the future, scroll).
2019-06-19 14:17:43 +02:00
struct damage {
enum damage_type type;
damage: remove 'scroll' sub struct There is no other types of damage but scroll damage.
2020-04-26 12:47:19 +02:00
struct scroll_region region;
int lines;
Use a 'damage' list to communicate what needs to be updated Instead of having each cell in the grid track it's own dirtiness, grid operations now append "damage" to a list. This list is consumed every time we render the grid. This allows us to special case some operations, like erase (and in the future, scroll).
2019-06-19 14:17:43 +02:00
};
grid: enable rows to have ‘extra’ data associated with them This patch adds an ‘extra’ member to the row struct. It is a pointer to a struct containing extra data to be associated with this row. Initially, this struct contains a list of URL ranges. These define (OSC-8) URLs on this row. The ‘extra’ data is allocated on-demand. I.e. the pointer is NULL by default; it is *not* allocated by grid_row_alloc().
2021-02-13 12:31:55 +01:00
struct row_uri_range {
int start;
int end;
term: add an ‘id’ member to the the ‘row_uri_range’ struct term_osc8_close() sets it from the OSC-8 ID tracked in the VT sub-struct.
2021-02-13 13:44:58 +01:00
uint64_t id;
grid: enable rows to have ‘extra’ data associated with them This patch adds an ‘extra’ member to the row struct. It is a pointer to a struct containing extra data to be associated with this row. Initially, this struct contains a list of URL ranges. These define (OSC-8) URLs on this row. The ‘extra’ data is allocated on-demand. I.e. the pointer is NULL by default; it is *not* allocated by grid_row_alloc().
2021-02-13 12:31:55 +01:00
char *uri;
};
struct row_data {
tll(struct row_uri_range) uri_ranges;
};
wip: grid is now represented as a grid, not a linear array The grid is now represented with an array of row *pointers*. Each row contains an array of cells (the row's columns). The main point of having row pointers is we can now move rows around almost for free. This is useful when scrolling with scroll margins for example, where we previously had to copy the lines in the margins. Now it's just a matter of swapping two pointers.
2019-07-08 13:57:31 +02:00
struct row {
struct cell *cells;
bool dirty;
term: convert cell 'linefeed' attribute to a row 'linebreak' property To do text reflow, we only need to know if a line has been explicitly linebreaked or not. If not, that means it wrapped, and that we should *not* insert a linebreak when reflowing text. When reflowing text, when reaching the end of a row in the old grid, only insert a linebreak in the new grid if the old row had been explicitly linebreaked. Furthermore, when reflowing text and wrapping a row in the new grid, mark the previous row as linebreaked if either the last cell was (the last column in the last row) empty, or the current cell (the first column in the new row) is empty. If both are non-empty, then we assume a linewrap.
2020-02-14 22:39:26 +01:00
bool linebreak;
grid: enable rows to have ‘extra’ data associated with them This patch adds an ‘extra’ member to the row struct. It is a pointer to a struct containing extra data to be associated with this row. Initially, this struct contains a list of URL ranges. These define (OSC-8) URLs on this row. The ‘extra’ data is allocated on-demand. I.e. the pointer is NULL by default; it is *not* allocated by grid_row_alloc().
2021-02-13 12:31:55 +01:00
struct row_data *extra;
wip: grid is now represented as a grid, not a linear array The grid is now represented with an array of row *pointers*. Each row contains an array of cells (the row's columns). The main point of having row pointers is we can now move rows around almost for free. This is useful when scrolling with scroll margins for example, where we previously had to copy the lines in the margins. Now it's just a matter of swapping two pointers.
2019-07-08 13:57:31 +02:00
};
sixel: improve handling of images when reflowing the grids Update the sixels' 'row' attribute when re-flowing a grid, to ensure it is rendered at the correct place. This should work in most cases, but will break when the cell size has changed (e.g. font size increase/decrease, or a DPI change). This patch also moves the sixel image list from the terminal struct into the grid struct. The sixels are per-grid after all.
2020-03-13 18:44:23 +01:00
struct sixel {
void *data;
pixman_image_t *pix;
int width;
int height;
int rows;
sixel: don't erase image when printing text *next* to it.
2020-06-06 13:59:46 +02:00
int cols;
sixel: improve handling of images when reflowing the grids Update the sixels' 'row' attribute when re-flowing a grid, to ensure it is rendered at the correct place. This should work in most cases, but will break when the cell size has changed (e.g. font size increase/decrease, or a DPI change). This patch also moves the sixel image list from the terminal struct into the grid struct. The sixels are per-grid after all.
2020-03-13 18:44:23 +01:00
struct coord pos;
sixel: implement P2=1 - transparent pixels When P2=1, empty pixels are transparent. This patch also changes the behavior of P2=0|2, from setting empty pixels to the default background color, to instead use the *current* background color. To implement this, a couple of changes are needed: * Sixel pixels always use alpha=1.0, except for *empty* cells when P2=1 (i.e. transparent pixels). * The renderer draws sixels with the OVER operator, instead of the SRC operator. * The renderer *must* now render the cells beneath the sixel. As an optimization, this is only done for sixels where P2=1. I.e. for fully opaque sixels, there’s no need to render the cells beneath. The sixel renderer isn’t yet hooked into the multi-threaded renderer. This means *rows* (not just the cells) beneath maybe-transparent sixels are rendered single-threaded. Closes #391.
2021-03-09 17:23:55 +01:00
bool opaque;
sixel: improve handling of images when reflowing the grids Update the sixels' 'row' attribute when re-flowing a grid, to ensure it is rendered at the correct place. This should work in most cases, but will break when the cell size has changed (e.g. font size increase/decrease, or a DPI change). This patch also moves the sixel image list from the terminal struct into the grid struct. The sixels are per-grid after all.
2020-03-13 18:44:23 +01:00
};
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
struct grid {
wip: grid is now represented as a grid, not a linear array The grid is now represented with an array of row *pointers*. Each row contains an array of cells (the row's columns). The main point of having row pointers is we can now move rows around almost for free. This is useful when scrolling with scroll margins for example, where we previously had to copy the lines in the margins. Now it's just a matter of swapping two pointers.
2019-07-08 13:57:31 +02:00
int num_rows;
grid: don't pre-allocate the entire grid (with all scrollback lines) The row array may now contain NULL pointers. This means the corresponding row hasn't yet been allocated and initialized. On a resize, we explicitly allocate the visible rows. Uninitialized rows are then allocated the first time they are referenced.
2019-07-10 16:27:55 +02:00
int num_cols;
wip: use a sliding window instead of memmove() to scroll Instead of memmoving a large amount of data on every scroll, use a sliding window. That is, each time we scroll, we offset origin.
2019-07-01 12:23:38 +02:00
int offset;
wip: initial scroll back support Can scroll up and down, and stops when the beginning/end of history is reached. However, it probably breaks when the entire scrollback buffer has been filled - we need to detect when the view has wrapped around to the current terminal offset. The detection of when we've reached the bottom of the history is also flawed, and only works when we overshoot the bottom with at least a page. Resizing the windows while in a view most likely doesn't work. The view will not detect a wrapped around scrollback buffer. I.e. if the user has scrolled back, and is stationary at a view, but there is still output being produced. Then eventually the scrollback buffer will wrap around. In this case, the correct thing to do is make the view start following the beginning of the history. Right now it doesn't, meaning once the scrollback buffer wraps around, you'll start seeing command output...
2019-07-09 16:26:36 +02:00
int view;
terminal: prepare for floating grids
2019-06-29 21:23:36 +02:00
term: keep cursor state in grid, for now, but document that it _could_ be moved
2021-01-15 18:02:17 +01:00
/*
* Note: the cursor (not the *saved* cursor) could most likely be
* global state in the term struct.
*
* However, we have grid specific functions that does not have
* access to the owning term struct, but does need access to the
* cursor.
*/
grid: move 'cursor' state from terminal to grid This way, the 'normal' and 'alt' grids have their own cursor state, and we don't need to switch between them.
2020-04-16 18:51:14 +02:00
struct cursor cursor;
struct cursor saved_cursor;
wip: grid is now represented as a grid, not a linear array The grid is now represented with an array of row *pointers*. Each row contains an array of cells (the row's columns). The main point of having row pointers is we can now move rows around almost for free. This is useful when scrolling with scroll margins for example, where we previously had to copy the lines in the margins. Now it's just a matter of swapping two pointers.
2019-07-08 13:57:31 +02:00
struct row **rows;
struct row *cur_row;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
scroll-region: don't clear damage queue when changing scroll region Vim, for example, changes the scroll region every time you scroll a single line. Thus, resetting the damage queue is slow. This reworks the damage handling of scroll updates: * Split damage queue into two: one for scroll operations and one for update/erase operations. * Don't separate update/erase operations inside/outside the scroll region * Store the current scroll region in the scroll damage operation. This allows us to stack multiple scroll operations with different scroll regions. * When updating update/erase operations after a scroll operation, split the update/erase operations if necessary (the current scroll operation may have a scroll region different from before, thus forcing us to split existing update/erase operations. * The renderer no longer erases after a scroll. The scroll operation also adds an erase operation. This also means that erase operation are subject to adjustments by later scroll operations.
2019-06-25 20:11:08 +02:00
tll(struct damage) scroll_damage;
sixel: improve handling of images when reflowing the grids Update the sixels' 'row' attribute when re-flowing a grid, to ensure it is rendered at the correct place. This should work in most cases, but will break when the cell size has changed (e.g. font size increase/decrease, or a DPI change). This patch also moves the sixel image list from the terminal struct into the grid struct. The sixels are per-grid after all.
2020-03-13 18:44:23 +01:00
tll(struct sixel) sixel_images;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
};
vt: implement DECCKM (cursor key sends either SS3 or CSI escapes)
2019-06-23 14:12:20 +02:00
struct vt_subparams {
unsigned value[16];
vt: use 8-bit indices for parameters and sub parameters We only support 16 (sub) parameters and thus there's no need for 64-bit index variables.
2020-02-01 19:24:46 +01:00
uint8_t idx;
vt: implement DECCKM (cursor key sends either SS3 or CSI escapes)
2019-06-23 14:12:20 +02:00
};
struct vt_param {
unsigned value;
struct vt_subparams sub;
};
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
struct vt {
int state; /* enum state */
csi: implement REP - CSI Ps b
2020-01-20 18:37:20 +01:00
wchar_t last_printed;
wip: grapheme shaping
2020-08-20 19:25:35 +02:00
#if defined(FOOT_GRAPHEME_CLUSTERING)
utf8proc_int32_t grapheme_state;
#endif
vt: initial version of UTF-8 decoding built-in into the VT parser
2020-06-07 16:16:50 +02:00
wchar_t utf8;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
struct {
vt: implement DECCKM (cursor key sends either SS3 or CSI escapes)
2019-06-23 14:12:20 +02:00
struct vt_param v[16];
vt: use 8-bit indices for parameters and sub parameters We only support 16 (sub) parameters and thus there's no need for 64-bit index variables.
2020-02-01 19:24:46 +01:00
uint8_t idx;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
} params;
terminal: add OSC-8 state tracking to the VT sub-struct
2021-02-13 12:34:11 +01:00
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
uint32_t private; /* LSB=priv0, MSB=priv3 */
terminal: add OSC-8 state tracking to the VT sub-struct
2021-02-13 12:34:11 +01:00
struct attributes attrs;
struct attributes saved_attrs;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
struct {
osc: allocate data buffer dynamically
2019-07-19 08:59:35 +02:00
uint8_t *data;
size_t size;
osc: implement change window title and icon
2019-07-05 09:46:48 +02:00
size_t idx;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
} osc;
terminal: add OSC-8 state tracking to the VT sub-struct
2021-02-13 12:34:11 +01:00
/* Start coordinate for current OSC-8 URI */
struct {
term: add ‘id’ parameter to term_osc8_open() The current OSC-8 URL’s ID is now tracked along with the URI itself, and its starting point.
2021-02-13 13:44:07 +01:00
uint64_t id;
terminal: add OSC-8 state tracking to the VT sub-struct
2021-02-13 12:34:11 +01:00
char *uri;
term: add ‘id’ parameter to term_osc8_open() The current OSC-8 URL’s ID is now tracked along with the URI itself, and its starting point.
2021-02-13 13:44:07 +01:00
struct coord begin;
terminal: add OSC-8 state tracking to the VT sub-struct
2021-02-13 12:34:11 +01:00
} osc8;
dcs: initial handling of DCS in general Add data structure to term->vt. This structure tracks the free-form data that is passed-through, and the handler to call at the end. Intermediates and parameters are collected by the normal VT parser. Then, when we enter the passthrough state, we call dcs_hook(). This function checks the intermediate(s) and parameters, and selects the appropriate unhook handler (and optionally does some execution already). In passthrough mode, we simply append strings to an internal buffer. This might have to be changed in the future, if we need to support a DCS that needs to execute as we go. In unhook (i.e. when the DCS is terminated), we execute the unhook handler. As a proof-of-concept, handlers for BSU/ESU (Begin/End Synchronized Update) has been added (but are left unimplemented).
2020-01-12 11:55:22 +01:00
struct {
uint8_t *data;
size_t size;
size_t idx;
sixel: initial support This implements basic parsing of sixel data. Lots of limitations and temporary solutions as this is still work-in-progress: * Maximum image size hardcoded to 800x800 * No HLS color format support * Image is always rendered at 0x0 in the terminal
2020-02-21 21:53:23 +01:00
void (*put_handler)(struct terminal *term, uint8_t c);
dcs: initial handling of DCS in general Add data structure to term->vt. This structure tracks the free-form data that is passed-through, and the handler to call at the end. Intermediates and parameters are collected by the normal VT parser. Then, when we enter the passthrough state, we call dcs_hook(). This function checks the intermediate(s) and parameters, and selects the appropriate unhook handler (and optionally does some execution already). In passthrough mode, we simply append strings to an internal buffer. This might have to be changed in the future, if we need to support a DCS that needs to execute as we go. In unhook (i.e. when the DCS is terminated), we execute the unhook handler. As a proof-of-concept, handlers for BSU/ESU (Begin/End Synchronized Update) has been added (but are left unimplemented).
2020-01-12 11:55:22 +01:00
void (*unhook_handler)(struct terminal *term);
} dcs;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
};
csi: implement DECOM - switch cursor origin between absolute and relative The default is absolute mode, where 0,0 is the upper left corner of the screen. In relative mode, the origin is relative the top scroll margin. Internally, we always track the current cursor position in absolute mode. Every time we the client *sets* or *queries* the cursor position in relative mode, we translate it to absolute.
2019-11-05 13:27:37 +01:00
enum cursor_origin { ORIGIN_ABSOLUTE, ORIGIN_RELATIVE };
enum cursor_keys { CURSOR_KEYS_DONTCARE, CURSOR_KEYS_NORMAL, CURSOR_KEYS_APPLICATION };
terminal: rename and redefine cursor keys mode and keypad keys mode
2019-07-09 11:07:06 +02:00
enum keypad_keys { KEYPAD_DONTCARE, KEYPAD_NUMERICAL, KEYPAD_APPLICATION };
vt: track charsets G0-G3 and support either ASCII or graphical mode
2019-07-04 19:17:18 +02:00
enum charset { CHARSET_ASCII, CHARSET_GRAPHIC };
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
enum charset_designator { G0, G1, G2, G3 };
vt: implement DECCKM (cursor key sends either SS3 or CSI escapes)
2019-06-23 14:12:20 +02:00
term: convert anonymous 'charsets' struct to a named struct
2019-11-17 10:00:30 +01:00
struct charsets {
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
enum charset_designator selected;
enum charset_designator saved;
term: convert anonymous 'charsets' struct to a named struct
2019-11-17 10:00:30 +01:00
enum charset set[4]; /* G0-G3 */
};
vt: add support for \E[?1000h - report mouse button events
2019-07-05 14:24:51 +02:00
/* *What* to report */
enum mouse_tracking {
MOUSE_NONE,
MOUSE_X10, /* ?9h */
term: xcursor: use 'hand2' instead of 'left_ptr' when mouse tracking Mouse tracking always reports clicks, so using a cursor that suggests you can click makes sense I think.
2019-11-29 22:30:56 +01:00
MOUSE_CLICK, /* ?1000h - report mouse clicks */
vt: add support for \E[?1000h - report mouse button events
2019-07-05 14:24:51 +02:00
MOUSE_DRAG, /* ?1002h - report clicks and drag motions */
term: xcursor: use 'hand2' instead of 'left_ptr' when mouse tracking Mouse tracking always reports clicks, so using a cursor that suggests you can click makes sense I think.
2019-11-29 22:30:56 +01:00
MOUSE_MOTION, /* ?1003h - report clicks and motion */
vt: add support for \E[?1000h - report mouse button events
2019-07-05 14:24:51 +02:00
};
/* *How* to report */
enum mouse_reporting {
MOUSE_NORMAL,
MOUSE_UTF8, /* ?1005h */
MOUSE_SGR, /* ?1006h */
MOUSE_URXVT, /* ?1015h */
};
config: add ‘beam-thickness’ option * Rename cursor.style value ‘bar’ to ‘beam’. ‘bar’ remains recognized, but should eventually be deprecated and then removed. * Add ‘cursor.beam-thickness’ option, a pt-or-px value specifying the thickness of the beam cursor. Defaults to 1.5pt. * Rename (and export) pt_or_px_as_pixels() to term_pt_or_px_as_pixels() * Change term_pt_or_px_as_pixels() to round point values instead of truncating them.
2021-04-30 20:31:47 +02:00
enum cursor_style { CURSOR_BLOCK, CURSOR_UNDERLINE, CURSOR_BEAM };
conf: make cursor's default style configurable
2019-07-22 20:15:14 +02:00
selection: combine enum selection_kind with selection_semantic
2021-01-06 10:53:27 +01:00
enum selection_kind {
SELECTION_NONE,
SELECTION_CHAR_WISE,
SELECTION_WORD_WISE,
SELECTION_LINE_WISE,
SELECTION_BLOCK
};
selection: adjust start point when the selection changes direction Without this, the initial cell will always be selected, regardless of how the selection is moved to the left or right. With this patch, the initial cell will only be selected while the selection is being made in the original direction. Changing direction of the selection moves the start point to next/previous character.
2020-08-12 18:50:49 +02:00
enum selection_direction {SELECTION_UNDIR, SELECTION_LEFT, SELECTION_RIGHT};
selection: auto-scroll: add SELECTION_SCROLL_NOT as a scroll ‘direction’
2020-10-11 18:18:18 +02:00
enum selection_scroll_direction {SELECTION_SCROLL_NOT, SELECTION_SCROLL_UP, SELECTION_SCROLL_DOWN};
selection: track selection type; normal or block selection
2020-01-03 23:29:45 +01:00
term: asynchronous writes to slave Make ptmx non-blocking. Then, when writing data to the slave would have blocked, use the FDM to asynchronously write the remaining data. This is done by enabling EPOLLOUT on ptmx, and enqueueing all outgoing data. The FDM handler will go through the enqueued data, and once all of it has been written, we turn off EPOLLOUT again (thus switching back to synchronous writes)
2019-11-03 01:03:52 +01:00
struct ptmx_buffer {
void *data;
size_t len;
size_t idx;
};
term: add term_surface_kind(), and track currently active surface This is needed to handle pointer motion and button events correctly, since mouse actions in e.g. CSD surfaces are very different from mouse actions in the main window.
2020-02-24 22:38:35 +01:00
enum term_surface {
TERM_SURF_NONE,
TERM_SURF_GRID,
TERM_SURF_SEARCH,
term: term_surface_kind(): recognize the scrollback indicator sub-surface
2020-07-26 12:37:12 +02:00
TERM_SURF_SCROLLBACK_INDICATOR,
input: don't crash on mouse motion events on the render timer surface
2020-08-14 07:35:01 +02:00
TERM_SURF_RENDER_TIMER,
term: surface-kind: add TERM_SURF_JUMP_LABEL
2021-02-06 11:30:40 +01:00
TERM_SURF_JUMP_LABEL,
term: add term_surface_kind(), and track currently active surface This is needed to handle pointer motion and button events correctly, since mouse actions in e.g. CSD surfaces are very different from mouse actions in the main window.
2020-02-24 22:38:35 +01:00
TERM_SURF_TITLE,
TERM_SURF_BORDER_LEFT,
TERM_SURF_BORDER_RIGHT,
TERM_SURF_BORDER_TOP,
TERM_SURF_BORDER_BOTTOM,
csd: initial implementation of minimize/maximize/close buttons
2020-03-02 20:29:28 +01:00
TERM_SURF_BUTTON_MINIMIZE,
TERM_SURF_BUTTON_MAXIMIZE,
TERM_SURF_BUTTON_CLOSE,
term: add term_surface_kind(), and track currently active surface This is needed to handle pointer motion and button events correctly, since mouse actions in e.g. CSD surfaces are very different from mouse actions in the main window.
2020-02-24 22:38:35 +01:00
};
selection: block non-paste data from being sent to client while pasting While pasting data from the clipboard, block *all* other data from being sent to the client. This includes keyboard and mouse events, but also replies for VT queries. This is particularly important when bracketed paste has been enabled, since then the client will interpret *everything* between the bracketed paste start and end as paste data.
2020-08-22 09:14:18 +02:00
typedef tll(struct ptmx_buffer) ptmx_buffer_list_t;
config: add show-urls-copy action This works just like show-urls-launch, except that instead of opening the URL (typically using xdg-open), it is placed in the clipboard when activated.
2021-02-04 20:55:08 +01:00
enum url_action { URL_ACTION_COPY, URL_ACTION_LAUNCH };
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
struct url {
url-mode: multiple URL (parts) with the same ID is assigned a single key sequence In case an URL is split up into multiple parts, those parts are now treated as a single URL when it comes to key assignment. Only the *first* URL part is actually assigned a key combo. The other parts are ignored. We still highlight them, but for all other purposes they are ignored.
2021-02-13 13:45:59 +01:00
uint64_t id;
url-mode: store URL in UTF-8, not UTF-32 The only time the URL is actually in UTF-32 is when we’re collecting it (auto-detecting it) from the grid, since cells store their character(s) in UTF-32. Everything *after* that prefers the URL in UTF-8. So, do the conversion while collecting the URL. This patch also changes the URL activation code to strip the ‘file://user@host/’ prefix from file URIs that refer to files on the *local* computer.
2021-02-13 12:28:53 +01:00
char *url;
url-mode: fix key sequence generation * We were using the ‘back’ element of the list as prefix for the next iteration of sequences, instead of the element at index ‘offset’ * ALEN() on a wchar_t[] includes the NULL terminator. We don’t want that.
2021-02-07 00:01:29 +01:00
wchar_t *key;
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
struct coord start;
struct coord end;
config: add show-urls-copy action This works just like show-urls-launch, except that instead of opening the URL (typically using xdg-open), it is placed in the clipboard when activated.
2021-02-04 20:55:08 +01:00
enum url_action action;
urls: OSC-8 URLs can now optionally be underlined outside of url-mode This patch adds a new configuration option, ‘osc8-underline=url-mode|always’. When set to ‘url-mode’, OSC-8 URLs are only highlighted (i.e. underlined) in url-mode, just like auto-detected URLs. When set to ‘always’, they are always underlined, regardless of mode, and regardless of their other attributes. This is implemented by tagging collected URLs with a boolean, instructing urls_render() and urls_reset() whether they should update the cells’ ‘url’ attribute or not. The OSC-8 collecter sets this based on the value of ‘osc8-underline’. Finally, when closing an OSC-8 URL, the cells are immediately tagged with the ‘url’ attribute if ‘osc8-underline’ is set to ‘always’.
2021-02-14 21:29:22 +01:00
bool url_mode_dont_change_url_attr; /* Entering/exiting URL mode doesn’t touch the cells’ attr.url */
url-mode: remove overlapping URLs, not just duplicates echo -e '\e]8;;https://www.foo.bar\e\\https://www.foo\e]8;;\e\\.bar' will produce an OSC-8 URL (https://www.foo) that is slightly shorter than the auto-detected one (https://www.foo.bar). This produces strange results in URL mode. For example, if url.osc8-underline=always, the OSC8 underline will be removed when url-mode is exited. This patch changes the behavior so that auto-detected URLs that overlap OSC-8 URLs are removed. Note that OSC-8 URLs cannot overlap with each other, and that auto-detected URLs also cannot overlap with each other.
2021-05-22 16:42:43 +02:00
bool osc8;
url-mode: fix crash when removing duplicate and/or overlapping URLs Removing overlaping and duplicated URLs is done by running two nested loops, that both iterate the same URL list. When a duplicate is found, one of the URLs is destroyed and removed from the list. Deleting and removing an item *is* safe, but only as long as _no other_ iterator has references to it. In this case, if we remove an item from e.g. the inner iterator, we’ll crash if the outer iterator’s *next* item is the item being removed. Closes #627
2021-07-11 10:06:12 +02:00
bool duplicate;
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
};
url-mode: urls_collect(): URL list pointer as an argument
2021-02-06 20:01:52 +01:00
typedef tll(struct url) url_list_t;
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
term: increase/decrease custom line-height with font size changes When the user has set a custom line-height, we now adjust it when increasing/decreasing (“zooming”) the font size at run-time. Previously, the line-height was fixed at the size specified in foot.ini.
2021-03-20 15:32:31 +01:00
/* If px != 0 then px is valid, otherwise pt is valid */
struct pt_or_px {
int16_t px;
float pt;
};
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
struct terminal {
terminal: implement term_init() and term_destroy()
2019-10-28 18:25:19 +01:00
struct fdm *fdm;
term: don't double fork new terminal windows Instead, register their PIDs with the new reaper module and let it handle them.
2020-05-21 20:17:29 +02:00
struct reaper *reaper;
term: add term_font_size_{increase,decrease}()
2020-02-08 14:09:06 +01:00
const struct config *conf;
terminal: implement term_init() and term_destroy()
2019-10-28 18:25:19 +01:00
term: runtime switch between a ‘fast’ and a ‘generic’ ASCII print function term_print() is called whenever the client application “prints” something to the grid. It is called for both ASCII and UTF-8 characters, and needs to handle sixels, insert mode and ASCII vs. graphical charsets. Since it’s on the hot path, this becomes unnecessarily slow. This patch adds a “fast” version of term_print(), tailored for the common case: ASCII characters in non-insert mode, without any sixels and non-graphical charsets. A new function, term_update_ascii_printer(), has been added, and must be called whenever: * The currently selected charset *index* changes * The currently selected charset changes (from ASCII to graphical, or vice verse) * Sixels are added to the grid * Sixels are removed from the grid * Insert mode is enabled/disabled
2021-03-14 19:19:10 +01:00
void (*ascii_printer)(struct terminal *term, wchar_t c);
wip: initial input handling
2019-06-19 10:04:47 +02:00
pid_t slave;
wip: vt parsing
2019-06-17 18:57:12 +02:00
int ptmx;
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
term: place frequently accessed members first in term struct To hopefully use the cache better.
2020-11-24 20:55:41 +01:00
struct vt vt;
struct grid *grid;
term: add term_font_size_{increase,decrease}()
2020-02-08 14:09:06 +01:00
struct grid normal;
struct grid alt;
term: place frequently accessed members first in term struct To hopefully use the cache better.
2020-11-24 20:55:41 +01:00
int cols; /* number of columns */
int rows; /* number of rows */
struct scroll_region scroll_region;
struct charsets charsets;
struct charsets saved_charsets; /* For save/restore cursor + attributes */
bool auto_margin;
bool insert_mode;
bool reverse;
bool hide_cursor;
bool reverse_wrap;
bool bracketed_paste;
bool focus_events;
bool alt_scrolling;
csi: add new private mode that makes the Escape key emit "\E[27;1;27~" This mode can be set by client programs with the DECSET, DECRST, XTSAVE and XTRESTORE sequences by using 27127 as the parameter. The sequence "\E[27;1;27~" is encoded in the same way as is done by xterm's "modifyOtherKeys" mode. Even though xterm itself never emits such a sequence for the Escape key, many programs already have support for parsing this style of key sequence.
2020-11-29 04:04:57 +00:00
bool modify_escape_key;
term: place frequently accessed members first in term struct To hopefully use the cache better.
2020-11-24 20:55:41 +01:00
enum cursor_origin origin;
enum cursor_keys cursor_keys_mode;
enum keypad_keys keypad_keys_mode;
enum mouse_tracking mouse_tracking;
enum mouse_reporting mouse_reporting;
tll(int) tab_stops;
term: add term_font_size_{increase,decrease}()
2020-02-08 14:09:06 +01:00
unicode-combining: store seen combining chains "globally" in the term struct Instead of storing combining data per cell, realize that most combinations are re-occurring and that there's lots of available space left in the unicode range, and store seen base+combining combinations chains in a per-terminal array. When we encounter a combining character, we first try to pre-compose, like before. If that fails, we then search for the current base+combining combo in the list of previously seen combinations. If not found there either, we allocate a new combo and add it to the list. Regardless, the result is an index into this array. We store this index, offsetted by COMB_CHARS_LO=0x40000000ul in the cell. When rendering, we need to check if the cell character is a plain character, or if it's a composed character (identified by checking if the cell character is >= COMB_CHARS_LO). Then we render the grapheme pretty much like before.
2020-05-03 11:03:22 +02:00
size_t composed_count;
struct composed *composed;
term: place frequently accessed members first in term struct To hopefully use the cache better.
2020-11-24 20:55:41 +01:00
/* Temporary: for FDM */
struct {
bool is_armed;
int lower_fd;
int upper_fd;
} delayed_render_timer;
fcft: adjust to fcft-2.0 API changes * font_*() -> fcft_*() * struct font -> struct fcft_font * struct glyph -> struct fcft_glyph * enum subpixel_order -> enum fcft_subpixel
2020-04-21 19:29:36 +02:00
struct fcft_font *fonts[4];
config: add font-bold, font-italic and font-bold-italic options These options lets the user configure custom fonts and styles, to use with the bold and italic cell attributes. By default, they are unset, meaning we use the bold/italic variants of the regular font. Closes #169.
2020-10-20 21:04:47 +02:00
struct config_font *font_sizes[4];
term: increase/decrease custom line-height with font size changes When the user has set a custom line-height, we now adjust it when increasing/decreasing (“zooming”) the font size at run-time. Previously, the line-height was fixed at the size specified in foot.ini.
2021-03-20 15:32:31 +01:00
struct pt_or_px font_line_height;
term: store current font DPI as a float instead of an integer FontConfig's DPI is a double, and using a float instead of an integer results in higher resolution.
2020-07-26 07:45:03 +02:00
float font_dpi;
config: line-height, letter-spacing: values are in pt by default, but we allow px If the value is specified without a unit, then the value is assumed to be in points, subject to DPI scaling. The value can optionally have a ‘px’ suffix, in which case the value is treated as a raw pixel count.
2021-01-07 17:00:58 +01:00
int16_t font_x_ofs;
int16_t font_y_ofs;
fcft: adjust to fcft-2.0 API changes * font_*() -> fcft_*() * struct font -> struct fcft_font * struct glyph -> struct fcft_glyph * enum subpixel_order -> enum fcft_subpixel
2020-04-21 19:29:36 +02:00
enum fcft_subpixel font_subpixel;
term: add term_font_size_{increase,decrease}()
2020-02-08 14:09:06 +01:00
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
/*
* 0-159: U+250U+259F
* 160-219: U+1FB00-1FB3B
box-drawing: add Unicode 13 U+1FB70 - U+1FB8B Part of #471
2021-05-03 17:57:16 +02:00
* 220-247: U+1FB70-1FB8B
box-drawing: SEXTANTS, U+1fb00-1fb3b
2020-12-29 13:02:08 +01:00
*/
box-drawing: add Unicode 13 U+1FB70 - U+1FB8B Part of #471
2021-05-03 17:57:16 +02:00
struct fcft_glyph *box_drawing[248];
box-drawing: add infrastructure for rendering box drawing characters ourselves * ‘term’ struct contains an array of 160 fcft glyph pointers * the glyph pointers are lazily allocated when we need to draw a box drawings character * Filtering out box drawings characters is easy - they are (except unicode 13, which isn’t handled yet )all in a single range.
2020-12-26 16:24:16 +01:00
selection: block non-paste data from being sent to client while pasting While pasting data from the clipboard, block *all* other data from being sent to the client. This includes keyboard and mouse events, but also replies for VT queries. This is particularly important when bracketed paste has been enabled, since then the client will interpret *everything* between the bracketed paste start and end as paste data.
2020-08-22 09:14:18 +02:00
bool is_sending_paste_data;
ptmx_buffer_list_t ptmx_buffers;
ptmx_buffer_list_t ptmx_paste_buffers;
term: asynchronous writes to slave Make ptmx non-blocking. Then, when writing data to the slave would have blocked, use the FDM to asynchronously write the remaining data. This is done by enabling EPOLLOUT on ptmx, and enqueueing all outgoing data. The FDM handler will go through the enqueued data, and once all of it has been written, we turn off EPOLLOUT again (thus switching back to synchronous writes)
2019-11-03 01:03:52 +01:00
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
struct {
bool esc_prefix;
bool eight_bit;
} meta;
csi: implement “CSI ? 1035” - toggle Num Lock override This adds a num_lock_modifier state to the terminal, and hooks up “CSI?1035h/l” to toggle it.
2020-11-11 18:26:47 +01:00
bool num_lock_modifier;
config: add ‘notify’ to possible values for ‘bell’ in foot.ini When `bell=notify`, foot will trigger a desktop notification when it receives a BEL in an unfocused window.
2020-12-10 18:22:48 +01:00
bool bell_action_enabled;
csi: implement ‘CSI ? 1042 h/l’ - enable/disable bell-is-urgent
2020-10-11 17:44:29 +02:00
csi: xtsave: store modes' SET state, not the current state
2020-08-16 16:57:39 +02:00
/* Saved DECSET modes - we save the SET state */
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
struct {
terminal: change type from uint32_t to bool in xtsave bitfield
2021-02-23 14:20:59 +01:00
bool origin:1;
bool application_cursor_keys:1;
bool reverse:1;
bool show_cursor:1;
bool reverse_wrap:1;
bool auto_margin:1;
bool cursor_blink:1;
bool bracketed_paste:1;
bool focus_events:1;
bool alt_scrolling:1;
//bool mouse_x10:1;
bool mouse_click:1;
bool mouse_drag:1;
bool mouse_motion:1;
//bool mouse_utf8:1;
bool mouse_sgr:1;
bool mouse_urxvt:1;
bool meta_eight_bit:1;
bool meta_esc_prefix:1;
bool num_lock_modifier:1;
bool bell_action_enabled:1;
bool alt_screen:1;
bool modify_escape_key:1;
bool ime:1;
csi: add support for DECSET 2026, as an alternative to BSU/ESU sequences See: https://gitlab.freedesktop.org/terminal-wg/specifications/-/merge_requests/2#note_847720
2021-04-25 18:35:46 +01:00
bool app_sync_updates:1;
terminal: change type from uint32_t to bool in xtsave bitfield
2021-02-23 14:20:59 +01:00
csi: invert the meaning of DECSDM There has been some confusion whether enabling DECSDM (private mode 80) enables or disables sixel scrolling. Foot currently enables scrolling when DECSDM is set, and this patch changes this, such that setting DECSDM now *disables* scrolling. The confusion is apparently due to a documentation error in the VT340 manual, as described in https://github.com/dankamongmen/notcurses/issues/1782#issuecomment-863603641. And that makes sense, in a way: the SDM in DECSDM stands for Sixel Display Mode. I.e. it stands to reason that enabling that disables scrolling. Anyway, this lead to https://github.com/hackerb9/lsix/issues/41, where it was eventually proven (by testing on a real VT340), that foot, and a large number of other terminals (including XTerm) has it wrong: https://github.com/hackerb9/lsix/issues/41#issuecomment-873269599.
2021-07-14 19:17:44 +02:00
bool sixel_display_mode:1;
terminal: change type from uint32_t to bool in xtsave bitfield
2021-02-23 14:20:59 +01:00
bool sixel_private_palette:1;
bool sixel_cursor_right_of_graphics:1;
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
} xtsave;
config: add locked-title=no|yes Closes #386
2021-07-04 17:59:40 +02:00
bool window_title_has_been_set;
term: track current window title in terminal struct
2019-07-21 17:35:53 +02:00
char *window_title;
csi: implement CSI 22t and CSI 23t 22;0|1|2t pushes the current window title/icon to the stack, while 23 pops it. The second parameter, 0|1|2 has the following meaning: 0 - push/pop icon+title 1 - push/pop icon 2 - push/pop title
2019-07-21 17:48:06 +02:00
tll(char *) window_title_stack;
vt: track charsets G0-G3 and support either ASCII or graphical mode
2019-07-04 19:17:18 +02:00
term: group 'flash' state together in a struct
2019-07-22 19:15:56 +02:00
struct {
bool active;
int fd;
} flash;
flash: implement 'flash' Use our own escape sequence for the 'flash' terminfo entry. Implemented by arming a timer FD and setting a boolean that indicates we're currently "flashing". The renderer draws a semi-transparent yellowish layer over the entire window when "flashing" is active.
2019-07-21 19:14:19 +02:00
term: group 'blink' state together in a struct
2019-07-22 19:17:57 +02:00
struct {
enum { BLINK_ON, BLINK_OFF } state;
int fd;
} blink;
blink: implement 'blink'
2019-07-21 20:11:20 +02:00
output: initial support for output scaling * Not updated run-time; only scale at start up used * Multiple monitors (outputs) not supported, as we can't track which output we're on (yet).
2019-08-12 21:22:38 +02:00
int scale;
render: break out rendering functions to render.{c,h}
2019-07-05 10:16:56 +02:00
int width; /* pixels */
int height; /* pixels */
wayland: properly restore window size when being un-tiled Bind to xdg-shell version 2 if available, as this enables us to track our window’s ‘tiled’ state in the ‘configure’ events. This in turn allows us to stash the ‘old’ window size when being tiled, to be used again when restoring the window size when un-tiled.
2020-10-20 20:58:03 +02:00
int stashed_width;
int stashed_height;
term: resize: pre-calculate right/bottom margins
2020-02-24 18:38:11 +01:00
struct {
int left;
int right;
int top;
int bottom;
} margins;
render: break out rendering functions to render.{c,h}
2019-07-05 10:16:56 +02:00
int cell_width; /* pixels per cell, x-wise */
int cell_height; /* pixels per cell, y-wise */
terminal: move col/row count, cell width/height and scroll region to terminal
2019-06-29 21:08:08 +02:00
term: prepare for configurable colors; add color variables to terminal
2019-07-21 10:58:09 +02:00
struct {
uint32_t fg;
uint32_t bg;
term: rename colors256 -> table
2019-08-21 18:50:24 +02:00
uint32_t table[256];
term: background alpha is not a floating point number
2020-01-03 21:53:16 +01:00
uint16_t alpha;
osc: implement OSC 17+19: change selection background/foreground colors And of course, we also implement the corresponding reset sequences, OSC 117+119.
2021-04-07 08:09:40 +02:00
uint32_t selection_fg;
uint32_t selection_bg;
bool use_custom_selection;
term: prepare for configurable colors; add color variables to terminal
2019-07-21 10:58:09 +02:00
} colors;
terminal: move cursor from grid to terminal
2019-06-29 21:15:32 +02:00
conf: make cursor's default style configurable
2019-07-22 20:15:14 +02:00
enum cursor_style cursor_style;
term: implement cursor blinking Blinking can be enabled either by setting the cursor style with CSI Ps SP q and selecting a blinking style. Or, with 'CSI ? 12 h' Note that both affect the same internal state. I.e. you can disable blinking with CSI ? 12l after having selected a blinking cursor style. This is consistent with XTerm behavior.
2019-12-15 15:07:56 +01:00
struct {
term: split cursor blink state into two There are two different escape sequences that can be used to set the cursor blink state: ‘CSI ? 12 h/l’ and ‘CSI Ps SP q’. Up until now, they both modified the same internal state in foot. This meant you could enable a blinking cursor with e.g. ‘CSI ? 12 h’ and then disable it with ‘CSI 2 SP q’. Since the ‘CSI ? 12’ escapes are used in the civis/cnorm/cvvis terminfo entries, applications often ended up disabling the blink state on exit (typically be emitting ‘cnorm’), requiring users to manually re-enable blinking. By splitting the internal state into two separate states, we can improve the situation. The cursor will blink if at least one of the two have been enabled. The setting in foot.ini sets the default state of the ‘CSI Ps SP q’ escape. This means if the user has enabled blinking in the configuration, the cursor will blink regardless of civis/cnorm/cvvis. Which probably is what the user wants. If the user has NOT enabled blinking, civis/cnorm/cvvis act as intended: cvvis blink, civis and cnorm do not. If an application overrides the cursor blink/style with ‘CSI Ps SP q’, that will override the user’s setting in foot.ini. But most likely that too is intended (for example, the user may have configured the application to use a different cursor style). And, a well written application will emit the ‘Se’ terminfo sequence on exit, which in foot is defined to ‘CSI SP q’, which will reset both the style and blink state to the user configured style/state. Closes #218
2020-11-26 18:09:32 +01:00
bool decset; /* Blink enabled via '\E[?12h' */
bool deccsusr; /* Blink enabled via '\E[X q' */
term: implement cursor blinking Blinking can be enabled either by setting the cursor style with CSI Ps SP q and selecting a blinking style. Or, with 'CSI ? 12 h' Note that both affect the same internal state. I.e. you can disable blinking with CSI ? 12l after having selected a blinking cursor style. This is consistent with XTerm behavior.
2019-12-15 15:07:56 +01:00
int fd;
term: split cursor blink state into two There are two different escape sequences that can be used to set the cursor blink state: ‘CSI ? 12 h/l’ and ‘CSI Ps SP q’. Up until now, they both modified the same internal state in foot. This meant you could enable a blinking cursor with e.g. ‘CSI ? 12 h’ and then disable it with ‘CSI 2 SP q’. Since the ‘CSI ? 12’ escapes are used in the civis/cnorm/cvvis terminfo entries, applications often ended up disabling the blink state on exit (typically be emitting ‘cnorm’), requiring users to manually re-enable blinking. By splitting the internal state into two separate states, we can improve the situation. The cursor will blink if at least one of the two have been enabled. The setting in foot.ini sets the default state of the ‘CSI Ps SP q’ escape. This means if the user has enabled blinking in the configuration, the cursor will blink regardless of civis/cnorm/cvvis. Which probably is what the user wants. If the user has NOT enabled blinking, civis/cnorm/cvvis act as intended: cvvis blink, civis and cnorm do not. If an application overrides the cursor blink/style with ‘CSI Ps SP q’, that will override the user’s setting in foot.ini. But most likely that too is intended (for example, the user may have configured the application to use a different cursor style). And, a well written application will emit the ‘Se’ terminfo sequence on exit, which in foot is defined to ‘CSI SP q’, which will reset both the style and blink state to the user configured style/state. Closes #218
2020-11-26 18:09:32 +01:00
enum { CURSOR_BLINK_ON, CURSOR_BLINK_OFF } state;
term: implement cursor blinking Blinking can be enabled either by setting the cursor style with CSI Ps SP q and selecting a blinking style. Or, with 'CSI ? 12 h' Note that both affect the same internal state. I.e. you can disable blinking with CSI ? 12l after having selected a blinking cursor style. This is consistent with XTerm behavior.
2019-12-15 15:07:56 +01:00
} cursor_blink;
conf: allow the user to configure a fixed cursor color The default is to reverse the foreground/background colors in the cell with the cursor. But, if the user configures a specific set of cursor colors, those will always be used, regardless of other cell attributes (dim, reverse etc). The cursor color is specified as two color values, 'text' and 'cursor'. The block cursor uses the 'cursor' color as background, and the 'text' color for the glyph. All other cursor styles uses the 'cursor' color for the cursor, but uses the cell's foreground color for the glyph (meaning, dim/reverse/etc applies).
2019-07-23 18:54:58 +02:00
struct {
uint32_t text;
uint32_t cursor;
} cursor_color;
terminal: prepare for floating grids
2019-06-29 21:23:36 +02:00
selection: selections can be made, and are rendered * Start selection on mouse button down * Update selection on motion * Button release cancels selection if there were no motion after start * Renderer detects cells inside the selection and inverts their colors
2019-07-10 20:57:09 +02:00
struct {
selection: track selection type; normal or block selection
2020-01-03 23:29:45 +01:00
enum selection_kind kind;
selection: adjust start point when the selection changes direction Without this, the initial cell will always be selected, regardless of how the selection is moved to the left or right. With this patch, the initial cell will only be selected while the selection is being made in the original direction. Changing direction of the selection moves the start point to next/previous character.
2020-08-12 18:50:49 +02:00
enum selection_direction direction;
selection: selections can be made, and are rendered * Start selection on mouse button down * Update selection on motion * Button release cancels selection if there were no motion after start * Renderer detects cells inside the selection and inverts their colors
2019-07-10 20:57:09 +02:00
struct coord start;
struct coord end;
config: add mouse specific bind actions This extends the "normal" bind action enum with mouse specific actions. When parsing key bindings, we only check up to the last valid keyboard binding, while mouse bindings support *both* key actions and mouse actions. The new actions are: * select-begin: starts an interactive selection * select-extend: interactively extend an existing selection * select-word: select word under cursor * select-word-whitespace: select word under cursor, where the only word separating characters are whitespace characters. The old hard-coded selection "bindings" have been converted to instead use these actions, via default bindings added to the configuration.
2020-08-11 09:55:33 +02:00
bool ongoing;
selection: remember whether word-wise selection uses spaces only for delimiters
2021-01-02 21:38:41 +01:00
bool spaces_only; /* SELECTION_SEMANTIC_WORD */
selection: auto-scroll: selection keeps scrolling while mouse is outside grid Moving the mouse outside the grid while we have an on-going selection now starts a timer. The interval of this timer depends on the mouse’s distance from the grid - the further away the mouse is, the shorter interval. On each timer timeout, we scroll one line, and update the selection. Thus, the shorter the interval, the faster we scroll. The timer is canceled as soon as the mouse enters the grid again, or the selection is either canceled or finalized. The timer FD is created and destroyed on-demand. Most of the logic is now in selection.c. The exception is the calculation of the timer interval, which depends on the mouse’s position. Thus, this is done in input.c. The scroll+selection update logic needs to know a) which direction we’re scrolling in, and b) which *column* the selection should be updated with. If the mouse is outside the grid’s left or right margins, the stored mouse column will be -1. I.e. we don’t know whether the mouse is on the left or right side of the grid. This is why the caller, that starts the timer, must provide this value. The same applies to top and bottom margins, but since we already have the scroll *direction*, which row value to use can be derived from this.
2020-10-11 15:44:20 +02:00
selection: allow selections to pivot around a range instead of a point Extend selection pivoting to allow selections to pivot around a range. Use this in word- and row-based selections to pivot around the initial word/row that was selected. This mimics the behavior of at least urxvt and xterm.
2021-01-03 13:11:46 +01:00
struct {
struct coord start;
struct coord end;
} pivot;
selection: auto-scroll: selection keeps scrolling while mouse is outside grid Moving the mouse outside the grid while we have an on-going selection now starts a timer. The interval of this timer depends on the mouse’s distance from the grid - the further away the mouse is, the shorter interval. On each timer timeout, we scroll one line, and update the selection. Thus, the shorter the interval, the faster we scroll. The timer is canceled as soon as the mouse enters the grid again, or the selection is either canceled or finalized. The timer FD is created and destroyed on-demand. Most of the logic is now in selection.c. The exception is the calculation of the timer interval, which depends on the mouse’s position. Thus, this is done in input.c. The scroll+selection update logic needs to know a) which direction we’re scrolling in, and b) which *column* the selection should be updated with. If the mouse is outside the grid’s left or right margins, the stored mouse column will be -1. I.e. we don’t know whether the mouse is on the left or right side of the grid. This is why the caller, that starts the timer, must provide this value. The same applies to top and bottom margins, but since we already have the scroll *direction*, which row value to use can be derived from this.
2020-10-11 15:44:20 +02:00
struct {
int fd;
int col;
enum selection_scroll_direction direction;
} auto_scroll;
selection: selections can be made, and are rendered * Start selection on mouse button down * Update selection on motion * Button release cancels selection if there were no motion after start * Renderer detects cells inside the selection and inverts their colors
2019-07-10 20:57:09 +02:00
} selection;
search: wip: re-direct input while searching, and build a search buffer This adds a new state, 'is_searching'. While active, input is re-directed, and stored in a search buffer. In the future, we'll use this buffer and search for its content in the scrollback buffer, and move the view and create a selection on matches. When rendering in 'is_searching', everything is dimmed. In the future, we'll render the current search buffer on-top of the dimmed "regular" terminal output.
2019-08-27 17:23:28 +02:00
bool is_searching;
struct {
wchar_t *buf;
size_t len;
size_t sz;
term: add a 'cursor' (position) to the search state
2019-08-29 21:02:35 +02:00
size_t cursor;
search: make search-direction configurable
2019-08-30 20:15:12 +02:00
enum { SEARCH_BACKWARD, SEARCH_FORWARD} direction;
search: wip: initial search matching * match search buffer against scrollback content * adjust view to ensure matched content is visible * create selection on a successful match * finalize selection when user presses enter (to "commit" the search) * ctrl+r searches for the next match. Needs more work though.
2019-08-27 19:33:19 +02:00
int original_view;
bool view_followed_offset;
struct coord match;
size_t match_len;
search: wip: re-direct input while searching, and build a search buffer This adds a new state, 'is_searching'. While active, input is re-directed, and stored in a search buffer. In the future, we'll use this buffer and search for its content in the scrollback buffer, and move the view and create a selection on matches. When rendering in 'is_searching', everything is dimmed. In the future, we'll render the current search buffer on-top of the dimmed "regular" terminal output.
2019-08-27 17:23:28 +02:00
} search;
term: wayland struct is now not a part of the terminal struct We do however need access to it, so provide a pointer. The difference is that now we can have a *single* wayland instance, but multiple terminal instances.
2019-10-27 18:51:14 +01:00
struct wayland *wl;
wayland: implement wayl_init() Wayland instantiation is now done by the wayland backend, not in main.
2019-10-27 19:08:48 +01:00
struct wl_window *window;
term: add visually focused attribute to terminal struct
2020-01-02 16:06:35 +01:00
bool visual_focus;
term: cache kbd-focused state, just like we cache visual focus state There's one difference however, when we receive a kbd unfocus call, *all* seats must have us unfocused before we actually change the state.
2020-07-11 09:04:46 +02:00
bool kbd_focus;
term: add term_surface_kind(), and track currently active surface This is needed to handle pointer motion and button events correctly, since mouse actions in e.g. CSD surfaces are very different from mouse actions in the main window.
2020-02-24 22:38:35 +01:00
enum term_surface active_surface;
term: move per-window wayland objects from wayland struct to terminal struct Short term, we want to break out the wayland backend from the terminal struct. Long term, we might want to support multiple windows. One step towards both the above is separating global wayland objects from per-window objects.
2019-10-27 12:57:37 +01:00
render: move frame_callback to term.render
2019-07-24 20:11:49 +02:00
struct {
shm: refactor: move away from a single, global, buffer list Up until now, *all* buffers have been tracked in a single, global buffer list. We've used 'cookies' to separate buffers from different contexts (so that shm_get_buffer() doesn't try to re-use e.g. a search-box buffer for the main grid). This patch refactors this, and completely removes the global list. Instead of cookies, we now use 'chains'. A chain tracks both the properties to apply to newly created buffers (scrollable, number of pixman instances to instantiate etc), as well as the instantiated buffers themselves. This means there's strictly speaking not much use for shm_fini() anymore, since its up to the chain owner to call shm_chain_free(), which will also purge all buffers. However, since purging a buffer may be deferred, if the buffer is owned by the compositor at the time of the call to shm_purge() or shm_chain_free(), we still keep a global 'deferred' list, on to which deferred buffers are pushed. shm_fini() iterates this list and destroys the buffers _even_ if they are still owned by the compositor. This only happens at program termination, and not when destroying a terminal instance. I.e. closing a window in a “foot --server” does *not* trigger this. Each terminal instatiates a number of chains, and these chains are destroyed when the terminal instance is destroyed. Note that some buffers may be put on the deferred list, as mentioned above.
2021-07-16 16:48:49 +02:00
struct {
struct buffer_chain *grid;
struct buffer_chain *search;
struct buffer_chain *scrollback_indicator;
struct buffer_chain *render_timer;
struct buffer_chain *url;
render: use a single backing SHM pool for CSD surface buffers
2021-07-18 16:46:43 +02:00
struct buffer_chain *csd;
shm: refactor: move away from a single, global, buffer list Up until now, *all* buffers have been tracked in a single, global buffer list. We've used 'cookies' to separate buffers from different contexts (so that shm_get_buffer() doesn't try to re-use e.g. a search-box buffer for the main grid). This patch refactors this, and completely removes the global list. Instead of cookies, we now use 'chains'. A chain tracks both the properties to apply to newly created buffers (scrollable, number of pixman instances to instantiate etc), as well as the instantiated buffers themselves. This means there's strictly speaking not much use for shm_fini() anymore, since its up to the chain owner to call shm_chain_free(), which will also purge all buffers. However, since purging a buffer may be deferred, if the buffer is owned by the compositor at the time of the call to shm_purge() or shm_chain_free(), we still keep a global 'deferred' list, on to which deferred buffers are pushed. shm_fini() iterates this list and destroys the buffers _even_ if they are still owned by the compositor. This only happens at program termination, and not when destroying a terminal instance. I.e. closing a window in a “foot --server” does *not* trigger this. Each terminal instatiates a number of chains, and these chains are destroyed when the terminal instance is destroyed. Note that some buffers may be put on the deferred list, as mentioned above.
2021-07-16 16:48:49 +02:00
} chains;
render: never render CSD and/or search box "immediately" Handle the CSDs and the search box the same way we handle the main grid; when we need to redraw them, call render_refresh_{csd,search}(). This sets a flag that is checked after each FDM iteration. All actual rendering is done here. This also ties the commits of the Wayland sub-surfaces to the commit of the main surface.
2020-03-06 19:16:54 +01:00
/* Scheduled for rendering, as soon-as-possible */
struct {
bool grid;
bool csd;
bool search;
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
bool urls;
render: never render CSD and/or search box "immediately" Handle the CSDs and the search box the same way we handle the main grid; when we need to redraw them, call render_refresh_{csd,search}(). This sets a flag that is checked after each FDM iteration. All actual rendering is done here. This also ties the commits of the Wayland sub-surfaces to the commit of the main surface.
2020-03-06 19:16:54 +01:00
} refresh;
/* Scheduled for rendering, in the next frame callback */
struct {
bool grid;
bool csd;
bool search;
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
bool urls;
render: never render CSD and/or search box "immediately" Handle the CSDs and the search box the same way we handle the main grid; when we need to redraw them, call render_refresh_{csd,search}(). This sets a flag that is checked after each FDM iteration. All actual rendering is done here. This also ties the commits of the Wayland sub-surfaces to the commit of the main surface.
2020-03-06 19:16:54 +01:00
} pending;
term: add term_damage_cursor() and term_damage_margins() term_damage_cursor() damages the cell where the cursor is currently at. This can be used to ensure the cursor is re-drawn, if there aren’t any other pending updates. term_damage_margins() requests the margins be redrawn the next time we render the grid.
2020-09-29 10:03:00 +02:00
bool margins; /* Someone explicitly requested a refresh of the margins */
bell: optionally render margins in red when receiving BEL Add anew config option, ‘bell=none|set-urgency’. When set to ‘set-urgency’, the margins will be painted in red (if the window did not have keyboard focus). This is intended as a cheap replacement for the ‘urgency’ hint, that doesn’t (yet) exist on Wayland. Closes #157
2020-10-08 19:55:32 +02:00
bool urgency; /* Signal 'urgency' (paint borders red) */
term: add term_damage_cursor() and term_damage_margins() term_damage_cursor() damages the cell where the cursor is currently at. This can be used to ensure the cursor is re-drawn, if there aren’t any other pending updates. term_damage_margins() requests the margins be redrawn the next time we render the grid.
2020-09-29 10:03:00 +02:00
render: use a timer instead of relying on the frame callback for title update throttling Using the frame callback works most of the time, but e.g. Sway doesn’t call it while the window is hidden, and thus prevents us from updating the title in e.g. stacked views. This patch uses a timer FD instead. We store a timestamp from when the title was last updated. When the application wants to update the title, we first check if we already have a timer running, and if so, does nothing. If no timer is running, check the timestamp. If enough time has passed, update the title immediately. If not, instantiate a timer and wait for it to trigger. Set the minimum time between two updates to ~8ms (twice per frame, for a 60Hz output, and ~once per frame on a 120Hz output). Closes #591
2021-06-15 17:27:50 +02:00
struct {
struct timeval last_update;
render: don’t create/destroy the title update timer each time Create it once when instantiating the terminal. Add a boolean to track whether the timer is running or not.
2021-06-18 15:53:47 +02:00
bool is_armed;
render: use a timer instead of relying on the frame callback for title update throttling Using the frame callback works most of the time, but e.g. Sway doesn’t call it while the window is hidden, and thus prevents us from updating the title in e.g. stacked views. This patch uses a timer FD instead. We store a timestamp from when the title was last updated. When the application wants to update the title, we first check if we already have a timer running, and if so, does nothing. If no timer is running, check the timestamp. If enough time has passed, update the title immediately. If not, instantiate a timer and wait for it to trigger. Set the minimum time between two updates to ~8ms (twice per frame, for a 60Hz output, and ~once per frame on a 120Hz output). Closes #591
2021-06-15 17:27:50 +02:00
int timer_fd;
} title;
term: more comments in the 'render' sub-struct
2020-01-04 19:56:59 +01:00
int scrollback_lines; /* Number of scrollback lines, from conf (TODO: move out from render struct?) */
render: move local static variables into the terminal struct
2019-07-24 20:21:41 +02:00
render: add a timeout for application synchronized updates This ensures we can recover from a crashing (or bad behaving) application that sends a BSU but then never sends an ESU.
2020-01-12 12:40:42 +01:00
struct {
bool enabled;
int timer_fd;
term: shorten application_synchronized_updates -> app_sync_updates
2020-01-12 12:55:19 +01:00
} app_sync_updates;
render: add a timeout for application synchronized updates This ensures we can recover from a crashing (or bad behaving) application that sends a BSU but then never sends an ESU.
2020-01-12 12:40:42 +01:00
term: more comments in the 'render' sub-struct
2020-01-04 19:56:59 +01:00
/* Render threads + synchronization primitives */
wip: initial multithreaded renderer
2019-07-29 20:13:26 +02:00
struct {
size_t count;
sem_t start;
sem_t done;
mtx_t lock;
tll(int) queue;
thrd_t *threads;
struct buffer *buf;
} workers;
render: move local static variables into the terminal struct
2019-07-24 20:21:41 +02:00
/* Last rendered cursor position */
struct {
render: remove most of the special handling of cursor rendering Previously, we had to explicitly render the old cursor cell *before* applying scrolling damage. We then rendered all the dirty rows, *without* rendering the cursor - even if the cursor cell was among the dirty rows. Finally, when everything else was done, we explicitly rendered the cursor cell. This meant a lot of code, and unnecessary render_cell() calls, along with unnecessary wl_surface_damage_buffer() calls. This was a necessary in the early design of foot, but not anymore. We can simply mark both the old cursor cell, and the current one, as dirty and let the normal rendering framework render it. All we need to do is pass the cursor column to render_row(), so that it can pass has_cursor=true in the appropriate call to render_cell(). We pass -1 here for all rows, except the cursor's row, where we pass the actual cursor column. With this, there's no need to calculate whether the cursor is visible or not; just mark it's cell as dirty, and if that row is visible, the normal rendering will take care of it. This also simplifies the state needed to be saved between two frames; we only need a row pointer, and the cursor column index. Part of https://codeberg.org/dnkl/foot/issues/35
2020-07-12 12:56:10 +02:00
struct row *row;
int col;
term: don't re-render last cursor cell if cursor was hidden
2020-07-15 08:21:41 +02:00
bool hidden;
render: move local static variables into the terminal struct
2019-07-24 20:21:41 +02:00
} last_cursor;
Revert "render: last_buf may point to a free:d buffer" This reverts commit 4d3251a93b4ba309d573aca6ff397df44c4ff760.
2019-11-02 01:28:29 +01:00
struct buffer *last_buf; /* Buffer we rendered to last time */
render: move local static variables into the terminal struct
2019-07-24 20:21:41 +02:00
bool was_flashing; /* Flash was active last time we rendered */
search: wip: re-direct input while searching, and build a search buffer This adds a new state, 'is_searching'. While active, input is re-directed, and stored in a search buffer. In the future, we'll use this buffer and search for its content in the scrollback buffer, and move the view and create a selection on matches. When rendering in 'is_searching', everything is dimmed. In the future, we'll render the current search buffer on-top of the dimmed "regular" terminal output.
2019-08-27 17:23:28 +02:00
bool was_searching;
wayland: optionally use the presentation time protocol to measure input lag This adds a flag, -p,--presentation-timings, that enables input lag measuring using the presentation time Wayland protocol. When enabled, we store a timestamp when we *send* a key to the slave. Then, when we commit a frame for rendering to the compositor, we request presentation feedback. We also store a timestamp for when the frame was committed. The 'presented' callback then looks at the input and commit timestamps, and compares it with the presented timestamp. The delay is logged at INFO when the delay was less than one frame interval, at WARN when it was one frame interval, and at ERR when it was two or more frame intervals. We also update statistic counters that we log when foot is shut down.
2019-12-31 15:39:40 +01:00
search: rename render.search_offset -> render.search_glyph_offset
2020-01-05 15:25:24 +01:00
size_t search_glyph_offset;
render: ensure cursor is always visible in the search box Maintain a view 'offset' (which glyph from the search string to start rendering at). This defines the start of the viewable area. The end is the offset + the search box size (which is limited to the window size). Adjust this offset whenever the cursor moves outside the viewable area. For now, this is always done in the same way: set the offset to the cursor position. This means that when we're entering text at the end of the search criteria (i.e. the normal case; we're simply typing), and the search box reaches the window size, the cursor will jump to the start of the search box, which will be empty. This could be confusing, but let's go with for now.
2020-01-05 15:16:40 +01:00
wayland: optionally use the presentation time protocol to measure input lag This adds a flag, -p,--presentation-timings, that enables input lag measuring using the presentation time Wayland protocol. When enabled, we store a timestamp when we *send* a key to the slave. Then, when we commit a frame for rendering to the compositor, we request presentation feedback. We also store a timestamp for when the frame was committed. The 'presented' callback then looks at the input and commit timestamps, and compares it with the presented timestamp. The delay is logged at INFO when the delay was less than one frame interval, at WARN when it was one frame interval, and at ERR when it was two or more frame intervals. We also update statistic counters that we log when foot is shut down.
2019-12-31 15:39:40 +01:00
bool presentation_timings;
struct timespec input_time;
render: move frame_callback to term.render
2019-07-24 20:11:49 +02:00
} render;
fdm: use the FDM's poll loop
2019-10-27 11:46:18 +01:00
sixel: initial support This implements basic parsing of sixel data. Lots of limitations and temporary solutions as this is still work-in-progress: * Maximum image size hardcoded to 800x800 * No HLS color format support * Image is always rendered at 0x0 in the terminal
2020-02-21 21:53:23 +01:00
struct {
sixel: clean up state machine Use proper state names, and implement the state machine using switch statements.
2020-02-22 11:30:30 +01:00
enum {
SIXEL_DECSIXEL, /* DECSIXEL body part ", $, -, ? ... ~ */
SIXEL_DECGRA, /* DECGRA Set Raster Attributes " Pan; Pad; Ph; Pv */
SIXEL_DECGRI, /* DECGRI Graphics Repeat Introducer ! Pn Ch */
term: place frequently accessed members first in term struct To hopefully use the cache better.
2020-11-24 20:55:41 +01:00
SIXEL_DECGCI, /* DECGCI Graphics Color Introducer # Pc; Pu; Px; Py; Pz */
sixel: clean up state machine Use proper state names, and implement the state machine using switch statements.
2020-02-22 11:30:30 +01:00
} state;
sixel: use a struct coord for current sixel position
2020-02-22 10:54:52 +01:00
struct coord pos; /* Current sixel coordinate */
sixel: empty pixels in the last sixel row doesn’t contribute to the image height All-empty pixels rows in the last sixel row should not be included in the final sixel image. This allows applications to emit sixels whose height is not a multiple of 6, and is how XTerm works. This is done by tracking the largest row number that contains non-empty pixels. In unhook, when emitting the image, the image height is adjusted based on this value.
2021-03-07 14:44:16 +01:00
int max_non_empty_row_no;
sixel: get rid of an ‘imul’ in sixel_add() By storing the current row’s byte offset into the backing image in the terminal struct. This replaces the ‘imul’ with a load, which can potentially be slow. But, this data should already be in the cache.
2021-03-06 22:05:40 +01:00
size_t row_byte_ofs; /* Byte position into image, for current row */
sixel: use a struct coord for current sixel position
2020-02-22 10:54:52 +01:00
int color_idx; /* Current palette index */
sixel: implement private mode 1070 - private color palette When enabled (the default), sixels use private color registers. That is, the color palette from the last sixel is *not* re-used. When disabled, sixels share (i.e. re-use) the same color palette. Closes #362
2021-02-16 19:37:49 +01:00
uint32_t *private_palette; /* Private palette, used when private mode 1070 is enabled */
uint32_t *shared_palette; /* Shared palette, used when private mode 1070 is disabled */
uint32_t *palette; /* Points to either private_palette or shared_palette */
sixel: resize image buffer dynamically
2020-02-22 10:46:35 +01:00
struct {
sixel: use a struct coord for current sixel position
2020-02-22 10:54:52 +01:00
uint32_t *data; /* Raw image data, in ARGB */
int width; /* Image width, in pixels */
int height; /* Image height, in pixels */
sixel: resize image buffer dynamically
2020-02-22 10:46:35 +01:00
} image;
sixel: initial support This implements basic parsing of sixel data. Lots of limitations and temporary solutions as this is still work-in-progress: * Maximum image size hardcoded to 800x800 * No HLS color format support * Image is always rendered at 0x0 in the terminal
2020-02-21 21:53:23 +01:00
sixel: implement private mode 80 - sixel scrolling When enabled (the default), sixels behave much like normal output; the start where the cursor is, and the cursor moves with the sixel. I.e. after emitting a sixel the cursor is left after the image; either to the right, if private mode 8452 is enabled, or otherwise on the next line. Terminal content is scrolled up if the sixel is larger than the screen. When disabled, sixels *always* start at (0,0), the cursor never moves, and the terminal content never scrolls. In other words, the ‘disabled’ mode is a much simpler mode. All we need to do to support both modes is re-write the sixel-emitting loop to: * break early if we’re “out of rows”, i.e. we’ve reached the bottom of the screen. * not linefeed, or move the cursor when scrolling is disabled This patch also fixes a bug in the (new) implementation of private mode 8452. When emitting a sixel, we may break it up into smaller pieces, to ensure a single sixel (as tracked internally) does not cross the scrollback wrap-around. The code that checked if we should do a linefeed or not, would skip the linefeed on the last row of *each* such sixel piece. The correct thing to do is to skip it only on the last row of the *last* piece. I chose not to fix this bug in a separate patch since doing so would have meant re-writing it again when implementing private mode 80.
2021-02-26 09:28:03 +01:00
bool scrolling:1; /* Private mode 80 */
bool use_private_palette:1; /* Private mode 1070 */
bool cursor_right_of_graphics:1; /* Private mode 8452 */
sixel: implement private mode 1070 - private color palette When enabled (the default), sixels use private color registers. That is, the color palette from the last sixel is *not* re-used. When disabled, sixels share (i.e. re-use) the same color palette. Closes #362
2021-02-16 19:37:49 +01:00
Fix some spelling mistakes
2020-08-15 19:39:00 +01:00
unsigned params[5]; /* Collected parameters, for RASTER, COLOR_SPEC */
sixel: clean up state machine Use proper state names, and implement the state machine using switch statements.
2020-02-22 11:30:30 +01:00
unsigned param; /* Currently collecting parameter, for RASTER, COLOR_SPEC and REPEAT */
sixel: use a struct coord for current sixel position
2020-02-22 10:54:52 +01:00
unsigned param_idx; /* Parameters seen */
sixel: application configurable palette size (color count) This implements the CSI escapes for retrieving and (re)setting the palette size.
2020-02-22 14:02:00 +01:00
sixel: implement P2=1 - transparent pixels When P2=1, empty pixels are transparent. This patch also changes the behavior of P2=0|2, from setting empty pixels to the default background color, to instead use the *current* background color. To implement this, a couple of changes are needed: * Sixel pixels always use alpha=1.0, except for *empty* cells when P2=1 (i.e. transparent pixels). * The renderer draws sixels with the OVER operator, instead of the SRC operator. * The renderer *must* now render the cells beneath the sixel. As an optimization, this is only done for sixels where P2=1. I.e. for fully opaque sixels, there’s no need to render the cells beneath. The sixel renderer isn’t yet hooked into the multi-threaded renderer. This means *rows* (not just the cells) beneath maybe-transparent sixels are rendered single-threaded. Closes #391.
2021-03-09 17:23:55 +01:00
bool transparent_bg;
sixel: application configurable palette size (color count) This implements the CSI escapes for retrieving and (re)setting the palette size.
2020-02-22 14:02:00 +01:00
/* Application configurable */
sixel: application configurable image max width/height
2020-02-22 21:03:24 +01:00
unsigned palette_size; /* Number of colors in palette */
unsigned max_width; /* Maximum image width, in pixels */
unsigned max_height; /* Maximum image height, in pixels */
sixel: initial support This implements basic parsing of sixel data. Lots of limitations and temporary solutions as this is still work-in-progress: * Maximum image size hardcoded to 800x800 * No HLS color format support * Image is always rendered at 0x0 in the terminal
2020-02-21 21:53:23 +01:00
} sixel;
url-mode: snapshot screen state when entering URL mode Previously, we automatically exited URL mode whenever we received data on the PTY. This was done since we don’t know _what_ has changed on the screen, and we don’t want to display misleading jump labels. However, this becomes a problem in curses-like applications that periodically updates part of the screen. For example, a statusbar with a clock. This patch changes this behavior; instead of cancelling URL mode when receiving PTY data, we snapshot the grid when entering URL mode. When *rendering*, we use the snapshot:ed grid, while PTY updates modify the “real” grid. Snapshot:ing the grid means taking a full/deep copy of the current grid, including sixel images etc. Finally, it isn’t necessary to “damage” the entire view when *entering* URL mode, since we’re at that point the renderer is in sync with the grid. But we *do* need to damage the entire view when exiting URL mode, since the grid changes on the “real” grid hasn’t been tracked by the renderer.
2021-02-22 10:22:41 +01:00
/* TODO: wrap in a struct */
url-mode: urls_collect(): URL list pointer as an argument
2021-02-06 20:01:52 +01:00
url_list_t urls;
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
wchar_t url_keys[5];
urls: add key binding that toggles whether URLs are displayed on jump-label By default, the URL isn’t shown on the jump-label. For auto-detect URLs, doing so is virtually always useless, as the URL is already visible in the grid. For OSC-8 URLs however, the URL is often _not_ visible in the grid. Many times, seeing the URL is still not needed (if you’re doing ‘ls --hyperlink’, you already know what the URIs are). But it is still useful to have a way to show the URLs. This patch adds a new key binding action that can be used in url-mode to toggle the URL on and off in the jump label. It is bound to ctrl+t by default.
2021-02-14 14:18:11 +01:00
bool urls_show_uri_on_jump_label;
url-mode: snapshot screen state when entering URL mode Previously, we automatically exited URL mode whenever we received data on the PTY. This was done since we don’t know _what_ has changed on the screen, and we don’t want to display misleading jump labels. However, this becomes a problem in curses-like applications that periodically updates part of the screen. For example, a statusbar with a clock. This patch changes this behavior; instead of cancelling URL mode when receiving PTY data, we snapshot the grid when entering URL mode. When *rendering*, we use the snapshot:ed grid, while PTY updates modify the “real” grid. Snapshot:ing the grid means taking a full/deep copy of the current grid, including sixel images etc. Finally, it isn’t necessary to “damage” the entire view when *entering* URL mode, since we’re at that point the renderer is in sync with the grid. But we *do* need to damage the entire view when exiting URL mode, since the grid changes on the “real” grid hasn’t been tracked by the renderer.
2021-02-22 10:22:41 +01:00
struct grid *url_grid_snapshot;
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
ime: make IME compile-time optional
2020-12-03 18:36:56 +01:00
#if defined(FOOT_IME_ENABLED) && FOOT_IME_ENABLED
ime: move preedit state from terminal struct to the seat struct This ensures different seat’s don’t step on each others IME pre-edit state. It also removes most dependencies on having a valid term pointer for many IME operations. We’re still not all the way, since we support disabling IME with a private mode, which is per terminal, not seat. Thus, we still require the seat to have keyboard focus on one of our windows. Closes #324. But note that *rendering* of multiple seat’s IME pre-edit strings is still broken.
2021-03-23 13:03:07 +01:00
bool ime_enabled;
ime: make IME compile-time optional
2020-12-03 18:36:56 +01:00
#endif
ime: render pre-edit text This is done by allocating cells for the pre-edit text when receiving the text-input::done() call, and populating them by converting the utf-8 formatted pre-edit text to wchars. We also convert the pre-edit cursor position to cell positions (it can cover multiple cells). When rendering, we simply render the pre-edit cells on-top off the regular grid. While doing so, we also mark the underlying, “real”, cells as dirty, to ensure they are re-rendered when the pre-edit text is modified or removed.
2020-12-02 18:52:50 +01:00
terminal: call user-defined callback when destroying terminal main uses this to get the exit code of the terminal.
2019-11-01 20:34:32 +01:00
bool is_shutting_down;
reaper: monitor SIGCHLD using the FDM instead of via a signalfd In addition to letting the FDM do the low-level signal watching, this patch also fixes a bug; multiple SIGCHLDs, be it delivered either through a signal, or via a signalfd, can be coalesced, like all signals. This means we need to loop on waitpid() with WNOHANG until there are no more processes to reap. This in turn requires a small change to the way reaper callbacks are implemented. Previously, the callback was allowed to do the wait(). This was signalled back to the reaper through the callback’s return value. Now, since we’ve already wait():ed, the process’ exit status is passed as an argument to the reaper callback. The callback for the client application has been updated accordingly; it sets a flag in the terminal struct, telling term_destroy() that the process has already been wait():ed on, and also stores the exit status.
2021-02-10 16:22:51 +01:00
bool slave_has_been_reaped;
term: asynchronous client application termination When the foot window is closed, and we need to terminate the client application, do this in an asynchronous fashion: * Don’t do a blocking call to waitpid(), instead, rely on the reaper callback * Use a timer FD to implement the timeout before sending SIGKILL (instead of using SIGALRM). * Send SIGTERM immediately (we used to *just* close the PTY, and then wait 2 seconds before sending SIGTERM). * Raise the timeout from 2 seconds to 60 Full shutdown now depends on *two* asynchronous tasks - unmapping the window, and waiting for the client application to terminate. Only when *both* of these have completed do we proceed and call term_destroy(), and the user provided shutdown callback.
2021-07-31 18:18:48 +02:00
int slave_terminate_timeout_fd;
reaper: monitor SIGCHLD using the FDM instead of via a signalfd In addition to letting the FDM do the low-level signal watching, this patch also fixes a bug; multiple SIGCHLDs, be it delivered either through a signal, or via a signalfd, can be coalesced, like all signals. This means we need to loop on waitpid() with WNOHANG until there are no more processes to reap. This in turn requires a small change to the way reaper callbacks are implemented. Previously, the callback was allowed to do the wait(). This was signalled back to the reaper through the callback’s return value. Now, since we’ve already wait():ed, the process’ exit status is passed as an argument to the reaper callback. The callback for the client application has been updated accordingly; it sets a flag in the terminal struct, telling term_destroy() that the process has already been wait():ed on, and also stores the exit status.
2021-02-10 16:22:51 +01:00
int exit_status;
terminal: call user-defined callback when destroying terminal main uses this to get the exit code of the terminal.
2019-11-01 20:34:32 +01:00
void (*shutdown_cb)(void *data, int exit_code);
void *shutdown_data;
term: term_spawn_new(): new function, spawns a new foot/footclient process Bind ctrl+shift+return to it
2019-12-21 15:27:17 +01:00
char *foot_exe;
term: wip: track current working directory This sets the initial current working directory, as it is when the terminal is instantiated. We chdir() to it just before spawning a new terminal.
2019-12-21 15:35:54 +01:00
char *cwd;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
};
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
config: add 'hide-when-typing' When enabled, the mouse cursor is hidden when the user types in the terminal. It is un-hidden when the user moves the mouse, or when the window loses keyboard focus.
2020-07-31 17:09:06 +02:00
extern const char *const XCURSOR_HIDDEN;
multi-seat: improve handling of multiple (mouse) pointers * xcursor always set for all pointers * xcursor sometimes not updated when it should be * mouse grabbed state wasn't per seat, but global (i.e. "does at least one seat enable mouse grabbing") * selection enabled state wasn't per seat
2020-07-09 09:52:11 +02:00
extern const char *const XCURSOR_LEFT_PTR;
extern const char *const XCURSOR_TEXT;
//extern const char *const XCURSOR_HAND2;
extern const char *const XCURSOR_TOP_LEFT_CORNER;
extern const char *const XCURSOR_TOP_RIGHT_CORNER;
extern const char *const XCURSOR_BOTTOM_LEFT_CORNER;
extern const char *const XCURSOR_BOTTOM_RIGHT_CORNER;
extern const char *const XCURSOR_LEFT_SIDE;
extern const char *const XCURSOR_RIGHT_SIDE;
extern const char *const XCURSOR_TOP_SIDE;
extern const char *const XCURSOR_BOTTOM_SIDE;
terminal: implement term_init() and term_destroy()
2019-10-28 18:25:19 +01:00
struct config;
struct terminal *term_init(
term: don't double fork new terminal windows Instead, register their PIDs with the new reaper module and let it handle them.
2020-05-21 20:17:29 +02:00
const struct config *conf, struct fdm *fdm, struct reaper *reaper,
struct wayland *wayl, const char *foot_exe, const char *cwd,
int argc, char *const *argv,
terminal: call user-defined callback when destroying terminal main uses this to get the exit code of the terminal.
2019-11-01 20:34:32 +01:00
void (*shutdown_cb)(void *data, int exit_code), void *shutdown_data);
term: add term_shutdown() This function unmaps the terminal window, removes itself from the wayland list of terminals and then finally destroys itself. We ensure we don't get any callbacks/events referring to a free:d terminal struct, we close all terminal related FDs and unmap the wayland window. Then, to be really really sure there aren't any (by the FDM) queued up events, we delay the self-destruction to the next FDM poll iteration, by opening an event FD and adding it to the FDM. The callback for the event FD removes the FD from the FDM again, and closes it. And then proceeds to destroy the terminal.
2019-10-30 20:03:11 +01:00
bool term_shutdown(struct terminal *term);
terminal: implement term_init() and term_destroy()
2019-10-28 18:25:19 +01:00
int term_destroy(struct terminal *term);
term: runtime switch between a ‘fast’ and a ‘generic’ ASCII print function term_print() is called whenever the client application “prints” something to the grid. It is called for both ASCII and UTF-8 characters, and needs to handle sixels, insert mode and ASCII vs. graphical charsets. Since it’s on the hot path, this becomes unnecessarily slow. This patch adds a “fast” version of term_print(), tailored for the common case: ASCII characters in non-insert mode, without any sixels and non-graphical charsets. A new function, term_update_ascii_printer(), has been added, and must be called whenever: * The currently selected charset *index* changes * The currently selected charset changes (from ASCII to graphical, or vice verse) * Sixels are added to the grid * Sixels are removed from the grid * Insert mode is enabled/disabled
2021-03-14 19:19:10 +01:00
void term_update_ascii_printer(struct terminal *term);
terminal: add 'charset_designator' enum to make code more self-documenting This commit also renames the term_set_single_shift_ascii_printer() function to term_single_shift(), since the former is overly verbose and not really even accurate.
2021-06-09 09:51:48 +01:00
void term_single_shift(struct terminal *term, enum charset_designator idx);
term: runtime switch between a ‘fast’ and a ‘generic’ ASCII print function term_print() is called whenever the client application “prints” something to the grid. It is called for both ASCII and UTF-8 characters, and needs to handle sixels, insert mode and ASCII vs. graphical charsets. Since it’s on the hot path, this becomes unnecessarily slow. This patch adds a “fast” version of term_print(), tailored for the common case: ASCII characters in non-insert mode, without any sixels and non-graphical charsets. A new function, term_update_ascii_printer(), has been added, and must be called whenever: * The currently selected charset *index* changes * The currently selected charset changes (from ASCII to graphical, or vice verse) * Sixels are added to the grid * Sixels are removed from the grid * Insert mode is enabled/disabled
2021-03-14 19:19:10 +01:00
term: implement reset
2019-08-01 20:51:11 +02:00
void term_reset(struct terminal *term, bool hard);
Rename: vt_to_slave() -> term_to_slave()
2019-11-03 00:27:39 +01:00
bool term_to_slave(struct terminal *term, const void *data, size_t len);
selection: block non-paste data from being sent to client while pasting While pasting data from the clipboard, block *all* other data from being sent to the client. This includes keyboard and mouse events, but also replies for VT queries. This is particularly important when bracketed paste has been enabled, since then the client will interpret *everything* between the bracketed paste start and end as paste data.
2020-08-22 09:14:18 +02:00
bool term_paste_data_to_slave(
struct terminal *term, const void *data, size_t len);
term: implement reset
2019-08-01 20:51:11 +02:00
term: implement term_font_dpi_changed() This function reloads the font *if* the DPI has changed. To handle user run-time adjusted font sizes, we record the number of adjustments made. Then, when re-loading the font, we first load the font as specified in the configuration. Then, we re-apply the size adjustment using font_size_adjust(). Note that this means we end up loading the fonts twice; first using the default size (but with adjusted DPI), and then again with the adjusted size. This can probably be improved upon. The existing font code has been refactored to avoid code duplication. For example, term_init() now calls term_font_dpi_changed() to load the initial fonts, instead of directly instantiating them. Finally, the way we calculate the DPI to use has changed: instead of using the highest DPI of all available outputs, we use the highest DPI of the output's we're actually mapped on. If we're not mapped at all, we use the globally highest DPI. Doing it this way means we usually only have to load the fonts once. Otherwise, we'd end up using the default DPI of 96 when the terminal is first instantiated (since it's not mapped at that time). On a single monitor system, we'll use the globally highest DPI at first, before being mapped. Then when we get mapped, we re-load the fonts using the highest mapped DPI. But since they'll be the same, we can skip actually reloading the fonts.
2020-02-15 19:08:14 +01:00
bool term_font_size_increase(struct terminal *term);
bool term_font_size_decrease(struct terminal *term);
bool term_font_size_reset(struct terminal *term);
term: get rid of term->font_scale, use term->scale only We only needed term->font_scale to be able to detect scaling factor changes (term->font_scale != term->scale). But, we already have the old scaling factor in all places where term_font_dpi_changed() is called, so let’s pass the old scaling factor as an argument instead.
2021-05-13 11:10:51 +02:00
bool term_font_dpi_changed(struct terminal *term, int old_scale);
render: use output's subpixel mode when rasterizing glyphs
2020-04-20 18:37:59 +02:00
void term_font_subpixel_changed(struct terminal *term);
config: add ‘beam-thickness’ option * Rename cursor.style value ‘bar’ to ‘beam’. ‘bar’ remains recognized, but should eventually be deprecated and then removed. * Add ‘cursor.beam-thickness’ option, a pt-or-px value specifying the thickness of the beam cursor. Defaults to 1.5pt. * Rename (and export) pt_or_px_as_pixels() to term_pt_or_px_as_pixels() * Change term_pt_or_px_as_pixels() to round point values instead of truncating them.
2021-04-30 20:31:47 +02:00
int term_pt_or_px_as_pixels(
const struct terminal *term, const struct pt_or_px *pt_or_px);
render: use output's subpixel mode when rasterizing glyphs
2020-04-20 18:37:59 +02:00
term: don't enable ptmx FDM callback until Wayland window has been configured The way things works right now, we cannot enable the ptmx FDM callback right away. We need to wait for the Wayland window to have been configured. Before the window is configured, we don't have a size, and no grid. Thus, if we try to process ptmx data we'll crash since we have no where to write it to. So, registering the ptmx fd with the FDM is now delayed until we've received the first 'configure' event from Wayland.
2020-04-30 17:22:57 +02:00
void term_window_configured(struct terminal *term);
term: add term_font_size_{increase,decrease}()
2020-02-08 14:09:06 +01:00
selection: add a selection API
2019-07-11 09:51:51 +02:00
void term_damage_rows(struct terminal *term, int start, int end);
void term_damage_rows_in_view(struct terminal *term, int start, int end);
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
void term_damage_all(struct terminal *term);
terminal: add term_damage_view() This ensures everything *visible* (i.e. maybe scrolled back content) is re-rendered.
2019-07-10 14:32:40 +02:00
void term_damage_view(struct terminal *term);
selection: add a selection API
2019-07-11 09:51:51 +02:00
term: add term_damage_cursor() and term_damage_margins() term_damage_cursor() damages the cell where the cursor is currently at. This can be used to ensure the cursor is re-drawn, if there aren’t any other pending updates. term_damage_margins() requests the margins be redrawn the next time we render the grid.
2020-09-29 10:03:00 +02:00
void term_damage_cursor(struct terminal *term);
void term_damage_margins(struct terminal *term);
term: add term_reset_view() - make view follow end-of-output again
2019-08-28 17:25:42 +02:00
void term_reset_view(struct terminal *term);
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
void term_damage_scroll(
struct terminal *term, enum damage_type damage_type,
struct scroll_region region, int lines);
wip: grid is now represented as a grid, not a linear array The grid is now represented with an array of row *pointers*. Each row contains an array of cells (the row's columns). The main point of having row pointers is we can now move rows around almost for free. This is useful when scrolling with scroll margins for example, where we previously had to copy the lines in the margins. Now it's just a matter of swapping two pointers.
2019-07-08 13:57:31 +02:00
void term_erase(
struct terminal *term, const struct coord *start, const struct coord *end);
csi: erase scrollback: cancel selection if it touches the scrollback This breaks out the scrollback erasing logic for \E[3J from csi.c, and moves it to the new function term_erase_scrollback(), and changes the logic to calculate the start and end row (absolute) numbers of the scrollback, and only iterate those, instead of iterating *all* rows, filtering out those that are on-screen. It also adds an intersection range check of the selection range, and cancels the selection if it touches any of the deleted scrollback rows. This fixes a crash when trying to render the next frame, since the selection now references rows that have been freed. Closes #633
2021-07-16 16:45:36 +02:00
void term_erase_scrollback(struct terminal *term);
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
term: try to improve on a performance regression When support was added for DECOM (absolute/relative row addressing), a small but noticeable (~3.5%) performance regression was introduced. Try to improve the situation by simplifying the relative-to-absolute conversion; only the row needs to be transformed.
2019-11-17 18:52:27 +01:00
int term_row_rel_to_abs(const struct terminal *term, int row);
csi: implement DECOM - switch cursor origin between absolute and relative The default is absolute mode, where 0,0 is the upper left corner of the screen. In relative mode, the origin is relative the top scroll margin. Internally, we always track the current cursor position in absolute mode. Every time we the client *sets* or *queries* the cursor position in relative mode, we translate it to absolute.
2019-11-05 13:27:37 +01:00
void term_cursor_home(struct terminal *term);
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
void term_cursor_to(struct terminal *term, int row, int col);
void term_cursor_left(struct terminal *term, int count);
void term_cursor_right(struct terminal *term, int count);
void term_cursor_up(struct terminal *term, int count);
void term_cursor_down(struct terminal *term, int count);
term: split cursor blink state into two There are two different escape sequences that can be used to set the cursor blink state: ‘CSI ? 12 h/l’ and ‘CSI Ps SP q’. Up until now, they both modified the same internal state in foot. This meant you could enable a blinking cursor with e.g. ‘CSI ? 12 h’ and then disable it with ‘CSI 2 SP q’. Since the ‘CSI ? 12’ escapes are used in the civis/cnorm/cvvis terminfo entries, applications often ended up disabling the blink state on exit (typically be emitting ‘cnorm’), requiring users to manually re-enable blinking. By splitting the internal state into two separate states, we can improve the situation. The cursor will blink if at least one of the two have been enabled. The setting in foot.ini sets the default state of the ‘CSI Ps SP q’ escape. This means if the user has enabled blinking in the configuration, the cursor will blink regardless of civis/cnorm/cvvis. Which probably is what the user wants. If the user has NOT enabled blinking, civis/cnorm/cvvis act as intended: cvvis blink, civis and cnorm do not. If an application overrides the cursor blink/style with ‘CSI Ps SP q’, that will override the user’s setting in foot.ini. But most likely that too is intended (for example, the user may have configured the application to use a different cursor style). And, a well written application will emit the ‘Se’ terminfo sequence on exit, which in foot is defined to ‘CSI SP q’, which will reset both the style and blink state to the user configured style/state. Closes #218
2020-11-26 18:09:32 +01:00
void term_cursor_blink_update(struct terminal *term);
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
term: factor out character printing to new function term_print()
2020-01-20 18:34:32 +01:00
void term_print(struct terminal *term, wchar_t wc, int width);
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
void term_scroll(struct terminal *term, int rows);
void term_scroll_reverse(struct terminal *term, int rows);
void term_scroll_partial(
struct terminal *term, struct scroll_region region, int rows);
void term_scroll_reverse_partial(
struct terminal *term, struct scroll_region region, int rows);
term: rename term_formfeed() -> term_carriage_return()
2020-07-14 09:29:10 +02:00
void term_carriage_return(struct terminal *term);
terminal: add term_linefeed() and term_reverse_index() linefeed moves cursor down one row (columns stays the same), or, if the cursor is at the last row, scrolls up one row. reverse_index does the opposite; it moves the cursor *up* one row, or, if the cursor is at the top row, scrolls *down* one row.
2019-07-10 16:02:03 +02:00
void term_linefeed(struct terminal *term);
void term_reverse_index(struct terminal *term);
render: move blink timer handling to term.c
2019-12-17 19:11:27 +01:00
void term_arm_blink_timer(struct terminal *term);
term/vt/csi: break out cursor save/restore to dedicated functions
2021-01-15 17:08:30 +01:00
void term_save_cursor(struct terminal *term);
alt-screen: use a custom 'saved' cursor when switching to alt screen This fixes an issue where we failed to restore the cursor correctly when exiting from the alternate screen, if the client had sent escapes to save the cursor position while inside the alternate screen. This was because we used the *same* storage for saving the cursor position through escapes, as for saving it when entering the alternate screen. Fix by using a custom variable dedicated to normal <--> alt screen switching.
2020-03-16 12:00:25 +01:00
void term_restore_cursor(struct terminal *term, const struct cursor *cursor);
term: make sure to update 'current row' when restoring saved cursor
2019-07-23 17:57:07 +02:00
term: add term_visual_focus_{in,out} These functions should be called when the terminal gets or loses visual focus. Note that this isn't necessarily the same as having keyboard focus.
2020-01-02 19:35:32 +01:00
void term_visual_focus_in(struct terminal *term);
void term_visual_focus_out(struct terminal *term);
term: rename term_focus_{in,out} -> term_kbd_focus_{in,out}
2020-01-02 19:29:42 +01:00
void term_kbd_focus_in(struct terminal *term);
void term_kbd_focus_out(struct terminal *term);
multi-seat: re-enable mouse button+motion reporting support
2020-07-08 18:16:43 +02:00
void term_mouse_down(
struct terminal *term, int button, int row, int col,
bool shift, bool alt, bool ctrl);
void term_mouse_up(
struct terminal *term, int button, int row, int col,
bool shift, bool alt, bool ctrl);
void term_mouse_motion(
struct terminal *term, int button, int row, int col,
bool shift, bool alt, bool ctrl);
multi-seat: improve handling of multiple (mouse) pointers * xcursor always set for all pointers * xcursor sometimes not updated when it should be * mouse grabbed state wasn't per seat, but global (i.e. "does at least one seat enable mouse grabbing") * selection enabled state wasn't per seat
2020-07-09 09:52:11 +02:00
bool term_mouse_grabbed(const struct terminal *term, struct seat *seat);
terminal: use the 'text' xcursor pointer whenever selection is possible
2019-11-28 19:35:47 +01:00
void term_xcursor_update(struct terminal *term);
config: add 'hide-when-typing' When enabled, the mouse cursor is hidden when the user types in the terminal. It is un-hidden when the user moves the mouse, or when the window loses keyboard focus.
2020-07-31 17:09:06 +02:00
void term_xcursor_update_for_seat(struct terminal *term, struct seat *seat);
term: track current window title in terminal struct
2019-07-21 17:35:53 +02:00
void term_set_window_title(struct terminal *term, const char *title);
term: break out 'flash' to a separate 'term' function
2019-07-30 22:06:02 +02:00
void term_flash(struct terminal *term, unsigned duration_ms);
bell: optionally render margins in red when receiving BEL Add anew config option, ‘bell=none|set-urgency’. When set to ‘set-urgency’, the margins will be painted in red (if the window did not have keyboard focus). This is intended as a cheap replacement for the ‘urgency’ hint, that doesn’t (yet) exist on Wayland. Closes #157
2020-10-08 19:55:32 +02:00
void term_bell(struct terminal *term);
term: term_spawn_new(): new function, spawns a new foot/footclient process Bind ctrl+shift+return to it
2019-12-21 15:27:17 +01:00
bool term_spawn_new(const struct terminal *term);
term/render: move {enable,disable}_application_synchronized_updates() From render -> terminal
2020-01-12 12:43:28 +01:00
term: shorten application_synchronized_updates -> app_sync_updates
2020-01-12 12:55:19 +01:00
void term_enable_app_sync_updates(struct terminal *term);
void term_disable_app_sync_updates(struct terminal *term);
term: add term_surface_kind(), and track currently active surface This is needed to handle pointer motion and button events correctly, since mouse actions in e.g. CSD surfaces are very different from mouse actions in the main window.
2020-02-24 22:38:35 +01:00
enum term_surface term_surface_kind(
const struct terminal *term, const struct wl_surface *surface);
extract: extract_one: make arguments const
2020-07-15 11:31:38 +02:00
term: add term_scrollback_to_text() and term_view_to_text() These functions extract the current view, or the entire scrollback as an UTF-8 encoded byte buffer.
2020-07-15 11:33:37 +02:00
bool term_scrollback_to_text(
const struct terminal *term, char **text, size_t *len);
bool term_view_to_text(
const struct terminal *term, char **text, size_t *len);
ime: make IME compile-time optional
2020-12-03 18:36:56 +01:00
ime: add functions to enable/disable IME, simplify code that enables IME We may want to be able to enable/disable IME run-time, even though we have received an ‘enter’ IME event. This enables us to do that. Also add functions to enable/disable IME on a per-terminal instance basis. A terminal may have multiple seats focusing it, and enabling/disabling IME in a terminal instance enables/disables IME on all those seats. Finally, the code to enable IME is simplified; the *only* surface that can ever receive ‘enter’ IME events is the main grid. All other surfaces are sub-surfaces, without their own keyboard focus.
2020-12-04 18:39:11 +01:00
bool term_ime_is_enabled(const struct terminal *term);
void term_ime_enable(struct terminal *term);
void term_ime_disable(struct terminal *term);
ime: move preedit state from terminal struct to the seat struct This ensures different seat’s don’t step on each others IME pre-edit state. It also removes most dependencies on having a valid term pointer for many IME operations. We’re still not all the way, since we support disabling IME with a private mode, which is per terminal, not seat. Thus, we still require the seat to have keyboard focus on one of our windows. Closes #324. But note that *rendering* of multiple seat’s IME pre-edit strings is still broken.
2021-03-23 13:03:07 +01:00
bool term_ime_reset(struct terminal *term);
Send text_input_rectangle requests for text-input
2020-12-20 15:01:21 -07:00
void term_ime_set_cursor_rect(
struct terminal *term, int x, int y, int width, int height);
urls: initial support for detecting URLs and rendering jump-labels The jump labels work, but is currently hardcoded to use xdg-open
2021-01-31 11:12:07 +01:00
void term_urls_reset(struct terminal *term);
void term_collect_urls(struct terminal *term);
terminal: add term_osc8_{open,close} functions These functions update the OSC-8 URI state in the terminal. term_osc8_open() tracks the beginning of an URL, by storing the start coordinate (i.e. the current cursor location), along with the URL itself. Note that term_osc8_open() may not be called with an empty URL. This is important to notice, since the way OSC-8 works, applications close an URL by “opening” a new, empty one: \E]8;;https://foo.bar\e\\this is an OSC-8 URL\E]8;;\e\\ It is up to the caller to check for this, and call term_osc8_close() instead of term_osc8_open() when the URL is empty. However, it is *also* valid to switch directly from one URL to another: \E]8;;http://123\e\\First URL\E]8;;http//456\e\\Second URL\E]8;;\e\\ This use-case *is* handled by term_osc8_open(). term_osc8_close() uses the information from term_osc8_open() to add per-row URL data (using the new ‘extra’ row data).
2021-02-13 12:34:48 +01:00
term: add ‘id’ parameter to term_osc8_open() The current OSC-8 URL’s ID is now tracked along with the URI itself, and its starting point.
2021-02-13 13:44:07 +01:00
void term_osc8_open(struct terminal *term, uint64_t id, const char *uri);
terminal: add term_osc8_{open,close} functions These functions update the OSC-8 URI state in the terminal. term_osc8_open() tracks the beginning of an URL, by storing the start coordinate (i.e. the current cursor location), along with the URL itself. Note that term_osc8_open() may not be called with an empty URL. This is important to notice, since the way OSC-8 works, applications close an URL by “opening” a new, empty one: \E]8;;https://foo.bar\e\\this is an OSC-8 URL\E]8;;\e\\ It is up to the caller to check for this, and call term_osc8_close() instead of term_osc8_open() when the URL is empty. However, it is *also* valid to switch directly from one URL to another: \E]8;;http://123\e\\First URL\E]8;;http//456\e\\Second URL\E]8;;\e\\ This use-case *is* handled by term_osc8_open(). term_osc8_close() uses the information from term_osc8_open() to add per-row URL data (using the new ‘extra’ row data).
2021-02-13 12:34:48 +01:00
void term_osc8_close(struct terminal *term);
wip: grapheme shaping
2020-08-20 19:25:35 +02:00
static inline void term_reset_grapheme_state(struct terminal *term)
{
#if defined(FOOT_GRAPHEME_CLUSTERING)
term->vt.grapheme_state = 0;
#endif
}
Reference in a new issue Copy permalink