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

646 lines
17 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
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"
#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"
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 {
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 bold:1;
uint32_t dim:1;
uint32_t italic:1;
uint32_t underline:1;
uint32_t strikethrough:1;
uint32_t blink:1;
uint32_t conceal:1;
uint32_t reverse:1;
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
render: add a 'clean' bit to each cell; only render cells that aren't clean This patch takes a bit from the foreground color value in a cell (todo: split up foreground/background into bitfields with a separate field for 'foreground/background' has been set), and only re-renders cells that aren't marked as clean. Note: we use a 'clean' bit rather than a 'dirty' bit to make it easy to erase cells - we can (keep doing) do that by simply memsetting a cell range to 0.
2019-07-30 18:03:03 +02:00
uint32_t clean: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 have_fg:1;
uint32_t 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: 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
uint32_t reserved:3;
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;
};
static_assert(sizeof(struct attributes) == 8, "bad size");
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
term: rename COMB_CHARS_LO,HI -> CELL_COMB_CHARS_LO,HI
2020-07-14 16:41:57 +02:00
#define CELL_COMB_CHARS_LO 0x40000000ul
#define CELL_COMB_CHARS_HI 0x400ffffful
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
#define CELL_MULT_COL_SPACER 0x40100000ul
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
};
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
struct composed {
wchar_t base;
wchar_t combining[5];
grid: add per-cell combining characters The data is *not* added to the cell struct, since that one is too performance critical. Instead, the data is added as a separate array in the row struct. This allows our performance critical code paths that e.g. clear cells to perform as before.
2020-05-01 11:49:11 +02:00
uint8_t count;
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
};
grid: add per-cell combining characters The data is *not* added to the cell struct, since that one is too performance critical. Instead, the data is added as a separate array in the row struct. This allows our performance critical code paths that e.g. clear cells to perform as before.
2020-05-01 11:49:11 +02:00
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;
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;
};
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;
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;
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 */
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;
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;
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
struct attributes attrs;
vt: implement save/restore cursor+attributes
2019-07-04 19:23:25 +02:00
struct attributes saved_attrs;
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 };
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 {
int selected;
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 */
};
conf: make cursor's default style configurable
2019-07-22 20:15:14 +02:00
enum cursor_style { CURSOR_BLOCK, CURSOR_UNDERLINE, CURSOR_BAR };
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: 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;
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
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: 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: add ‘dpi-aware’ option, defaulting to enabled When disabled, foot no longers uses outputs’ DPI to scale the font. Instead, it uses the outputs’ scaling factor. That is, instead of appending “:dpi=123” to the fontconfig string, modify the “:pixelsize” or “:size” attribute. Closes #206
2020-11-17 17:59:31 +01:00
int font_scale;
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
*/
struct fcft_glyph *box_drawing[220];
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 {
term: xtsave: store state in a bitfield These shouldn't be accessed in any performance critical paths, so lets save some memory and use a bitfield.
2020-08-16 16:58:32 +02:00
uint32_t origin:1;
uint32_t application_cursor_keys:1;
uint32_t reverse:1;
uint32_t show_cursor:1;
term: add private mode flag ‘’reverse-wrap’
2020-10-01 20:15:32 +02:00
uint32_t reverse_wrap:1;
term: xtsave: store state in a bitfield These shouldn't be accessed in any performance critical paths, so lets save some memory and use a bitfield.
2020-08-16 16:58:32 +02:00
uint32_t auto_margin:1;
csi: xtsave/xtrestore: implement \E[?12s and \E[?12r I.e. save/restore cursor-blink state.
2020-08-18 07:00:26 +02:00
uint32_t cursor_blink:1;
term: xtsave: store state in a bitfield These shouldn't be accessed in any performance critical paths, so lets save some memory and use a bitfield.
2020-08-16 16:58:32 +02:00
uint32_t bracketed_paste:1;
uint32_t focus_events:1;
uint32_t alt_scrolling:1;
//uint32_t mouse_x10:1;
uint32_t mouse_click:1;
uint32_t mouse_drag:1;
uint32_t mouse_motion:1;
//uint32_t mouse_utf8:1;
uint32_t mouse_sgr:1;
uint32_t mouse_urxvt:1;
uint32_t meta_eight_bit:1;
uint32_t meta_esc_prefix:1;
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
uint32_t num_lock_modifier:1;
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
uint32_t bell_action_enabled:1;
term: xtsave: store state in a bitfield These shouldn't be accessed in any performance critical paths, so lets save some memory and use a bitfield.
2020-08-16 16:58:32 +02:00
uint32_t alt_screen:1;
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
uint32_t modify_escape_key:1;
csi: add DECSET 737769 - enables/disables IME input 73 77 69 = I M E
2020-12-04 21:26:38 +01:00
uint32_t ime:1;
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
} xtsave;
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;
term: prepare for configurable colors; add color variables to terminal
2019-07-21 10:58:09 +02:00
uint32_t default_fg;
conf: config now provides the colors (though still only hardcoded colors)
2019-07-21 11:06:28 +02:00
uint32_t default_bg;
term: rename colors256 -> table
2019-08-21 18:50:24 +02:00
uint32_t default_table[256];
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 {
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;
render: pace title updates Synchronize window title updates with window rendering.
2020-03-25 18:23:55 +01:00
bool title;
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;
render: pace title updates Synchronize window title updates with window rendering.
2020-03-25 18:23:55 +01:00
bool title;
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
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 */
int color_idx; /* Current palette index */
int max_col; /* Largest column index we've seen (aka the image width) */
uint32_t *palette; /* Color 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: if the client has specified a size, do not change that We used to auto-resize images to always be a multiple of 6. This is incorrect. The client may, for example, have specified a size to align the image to a cell boundary, which may not be a multiple of 6. Furthermore, in e.g. Jexer, which splits up an image into stripes, that the next image would "overwrite" the previous one. Since the next image was started on a cell row that the previous image had overflowed into.
2020-06-11 18:40:52 +02:00
bool autosize;
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
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
/* 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;
ime: make IME compile-time optional
2020-12-03 18:36:56 +01:00
#if defined(FOOT_IME_ENABLED) && FOOT_IME_ENABLED
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
struct {
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 enabled;
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
struct {
ime: store wchar version of pre-edit string in terminal struct
2020-12-06 12:17:52 +01:00
wchar_t *text;
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
struct cell *cells;
int count;
struct {
bool hidden;
int start; /* Cell index, inclusive */
int end; /* Cell index, exclusive */
} cursor;
} preedit;
} ime;
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
term: place frequently accessed members first in term struct To hopefully use the cache better.
2020-11-24 20:55:41 +01:00
bool quit;
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;
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: 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);
bool term_font_dpi_changed(struct terminal *term);
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);
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);
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);
void term_ime_reset(struct terminal *term);
Reference in a new issue Copy permalink