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/csi.c

2220 lines
73 KiB
C
Raw Permalink Normal View History

wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
#include "csi.h"
wip: vt parsing
2019-06-17 18:57:12 +02:00
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
csi: CSI log messages are now single line
2019-06-18 21:55:39 +02:00
#if defined(_DEBUG)
#include <stdio.h>
#endif
csi: xtsave/xtrestore: implement \E[?12s and \E[?12r I.e. save/restore cursor-blink state.
2020-08-18 07:00:26 +02:00
#include <sys/timerfd.h>
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
#define LOG_MODULE "csi"
logging: disable debug logging by default
2019-07-03 20:21:03 +02:00
#define LOG_ENABLE_DBG 0
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
#include "log.h"
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
#include "char32.h"
term: remove read-only properties copied from the config Use the config directly instead.
2020-11-26 18:08:28 +01:00
#include "config.h"
Print stack trace on assert() failure or when calling fatal_error() Note: this uses the __sanitizer_print_stack_trace() function from the AddressSanitizer runtime, so it only works when AddressSanitizer is in use.
2021-01-15 20:39:45 +00:00
#include "debug.h"
wip: vt parsing: break out grid operating functions
2019-06-17 19:33:10 +02:00
#include "grid.h"
csi: cancel selection when switching between 'normal' and 'alt' grid
2019-07-11 10:00:59 +02:00
#include "selection.h"
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
#include "sixel.h"
util.h: new header file defining commonly used macros
2020-05-01 11:46:24 +02:00
#include "util.h"
csi: secondary DA: do not pretend we're xterm Previously, our secondary DA response indicated a) VT420, b) an XTerm version number. Now, we indicate VT220 (which corresponds to the primary DA response), and we report foot's version number as MMmmpp. I.e major, minor and patch versions, using two digits. E.g. 1.4.2 is encoded as 010402
2020-07-24 17:47:47 +02:00
#include "version.h"
#include "vt.h"
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
#include "xmalloc.h"
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
#include "xsnprintf.h"
csi: implement CSI Pn P (DCH - delete character)
2019-06-22 21:31:28 +02:00
csi: log only the un-handled parameter in a multi-operation CSI Assume we don't handle 'CSI 4 X'. Furthermore, assume we receive the following: 'CSI 1;2;3;4X'. In this case, only log '4X' as un-handled, not the entire CSI string.
2020-02-01 19:42:31 +01:00
#define UNHANDLED() LOG_DBG("unhandled: %s", csi_as_string(term, final, -1))
#define UNHANDLED_SGR(idx) LOG_DBG("unhandled: %s", csi_as_string(term, 'm', idx))
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
csi: sgr: treat CSI[m as CSI[0m (SGR reset)
2019-06-22 21:38:47 +02:00
static void
sgr_reset(struct terminal *term)
{
csi: sgr_reset(): avoid using memset() This _should_ be what the compiler does anyway (i.e. it _should_ replace the memset() with inline MOVs). But let's be sure.
2024-06-24 11:02:47 +02:00
term->vt.attrs = (struct attributes){0};
Rename various uses of "curly" in the source code with "underline" Since "curly" could make it seem as if all underline styles are curled (to people unfamiliar with the codebase), whereas in reality only 1 is.
2024-07-01 20:00:16 +01:00
term->vt.underline = (struct underline_range_data){0};
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
Rename various uses of "curly" in the source code with "underline" Since "curly" could make it seem as if all underline styles are curled (to people unfamiliar with the codebase), whereas in reality only 1 is.
2024-07-01 20:00:16 +01:00
term->bits_affecting_ascii_printer.underline_style = false;
term->bits_affecting_ascii_printer.underline_color = false;
term: performance: use a bitfield to track which ascii printer to use The things affecting which ASCII printer we use have grown... Instead of checking everything inside term_update_ascii_printer(), use a bitfield. Anything affecting the printer used, must now set a bit in this bitfield. This makes term_update_ascii_printer() much faster, since all it needs to do is check if the bitfield is zero or not.
2024-06-24 01:26:57 +02:00
term_update_ascii_printer(term);
csi: sgr: treat CSI[m as CSI[0m (SGR reset)
2019-06-22 21:38:47 +02:00
}
terminal: remove 'blink' attribute from cell struct This makes the other attribute bits fit in a single uint8_t, which makes each cell smaller which improves cache usage.
2019-07-10 18:45:12 +02:00
static const char *
csi: log only the un-handled parameter in a multi-operation CSI Assume we don't handle 'CSI 4 X'. Furthermore, assume we receive the following: 'CSI 1;2;3;4X'. In this case, only log '4X' as un-handled, not the entire CSI string.
2020-02-01 19:42:31 +01:00
csi_as_string(struct terminal *term, uint8_t final, int idx)
terminal: remove 'blink' attribute from cell struct This makes the other attribute bits fit in a single uint8_t, which makes each cell smaller which improves cache usage.
2019-07-10 18:45:12 +02:00
{
static char msg[1024];
int c = snprintf(msg, sizeof(msg), "CSI: ");
csi: log only the un-handled parameter in a multi-operation CSI Assume we don't handle 'CSI 4 X'. Furthermore, assume we receive the following: 'CSI 1;2;3;4X'. In this case, only log '4X' as un-handled, not the entire CSI string.
2020-02-01 19:42:31 +01:00
for (size_t i = idx >= 0 ? idx : 0;
i < (idx >= 0 ? idx + 1 : term->vt.params.idx);
i++)
{
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
c += snprintf(&msg[c], sizeof(msg) - c, "%u",
terminal: remove 'blink' attribute from cell struct This makes the other attribute bits fit in a single uint8_t, which makes each cell smaller which improves cache usage.
2019-07-10 18:45:12 +02:00
term->vt.params.v[i].value);
csi: fix wrong variable compared in for-loop
2019-07-18 14:13:35 +02:00
for (size_t j = 0; j < term->vt.params.v[i].sub.idx; j++) {
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
c += snprintf(&msg[c], sizeof(msg) - c, ":%u",
terminal: remove 'blink' attribute from cell struct This makes the other attribute bits fit in a single uint8_t, which makes each cell smaller which improves cache usage.
2019-07-10 18:45:12 +02:00
term->vt.params.v[i].sub.value[j]);
}
c += snprintf(&msg[c], sizeof(msg) - c, "%s",
i == term->vt.params.idx - 1 ? "" : ";");
}
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
for (size_t i = 0; i < sizeof(term->vt.private); i++) {
char value = (term->vt.private >> (i * 8)) & 0xff;
if (value == 0)
csi: debug: print 'private' *after* parameters
2020-06-30 17:42:57 +02:00
break;
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
c += snprintf(&msg[c], sizeof(msg) - c, "%c", value);
csi: debug: print 'private' *after* parameters
2020-06-30 17:42:57 +02:00
}
Fix clang warnings All are printf() formatter related. Even if a variable is e.g. a 'short', when used in an expression like '<variable> - 1' it is promoted to an 'int'. Closes #16
2020-04-12 18:20:52 +02:00
snprintf(&msg[c], sizeof(msg) - c, "%c (%u parameters)",
csi: log only the un-handled parameter in a multi-operation CSI Assume we don't handle 'CSI 4 X'. Furthermore, assume we receive the following: 'CSI 1;2;3;4X'. In this case, only log '4X' as un-handled, not the entire CSI string.
2020-02-01 19:42:31 +01:00
final, idx >= 0 ? 1 : term->vt.params.idx);
terminal: remove 'blink' attribute from cell struct This makes the other attribute bits fit in a single uint8_t, which makes each cell smaller which improves cache usage.
2019-07-10 18:45:12 +02:00
return msg;
}
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
static void
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
csi_sgr(struct terminal *term)
{
csi: sgr: treat CSI[m as CSI[0m (SGR reset)
2019-06-22 21:38:47 +02:00
if (term->vt.params.idx == 0) {
sgr_reset(term);
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
return;
csi: sgr: treat CSI[m as CSI[0m (SGR reset)
2019-06-22 21:38:47 +02:00
}
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
for (size_t i = 0; i < term->vt.params.idx; i++) {
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
const int param = term->vt.params.v[i].value;
switch (param) {
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
case 0:
csi: sgr: treat CSI[m as CSI[0m (SGR reset)
2019-06-22 21:38:47 +02:00
sgr_reset(term);
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
break;
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
case 1: term->vt.attrs.bold = true; break;
csi: move 'dim' attribute from 'vt' to cell attributes
2019-07-16 13:25:45 +02:00
case 2: term->vt.attrs.dim = true; break;
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
case 3: term->vt.attrs.italic = true; break;
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
case 4: {
term->vt.attrs.underline = true;
Rename various uses of "curly" in the source code with "underline" Since "curly" could make it seem as if all underline styles are curled (to people unfamiliar with the codebase), whereas in reality only 1 is.
2024-07-01 20:00:16 +01:00
term->vt.underline.style = UNDERLINE_SINGLE;
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
if (unlikely(term->vt.params.v[i].sub.idx == 1)) {
Rename various uses of "curly" in the source code with "underline" Since "curly" could make it seem as if all underline styles are curled (to people unfamiliar with the codebase), whereas in reality only 1 is.
2024-07-01 20:00:16 +01:00
enum underline_style style = term->vt.params.v[i].sub.value[0];
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
switch (style) {
default:
Rename various uses of "curly" in the source code with "underline" Since "curly" could make it seem as if all underline styles are curled (to people unfamiliar with the codebase), whereas in reality only 1 is.
2024-07-01 20:00:16 +01:00
case UNDERLINE_NONE:
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
term->vt.attrs.underline = false;
Rename various uses of "curly" in the source code with "underline" Since "curly" could make it seem as if all underline styles are curled (to people unfamiliar with the codebase), whereas in reality only 1 is.
2024-07-01 20:00:16 +01:00
term->vt.underline.style = UNDERLINE_NONE;
term->bits_affecting_ascii_printer.underline_style = false;
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
break;
Rename various uses of "curly" in the source code with "underline" Since "curly" could make it seem as if all underline styles are curled (to people unfamiliar with the codebase), whereas in reality only 1 is.
2024-07-01 20:00:16 +01:00
case UNDERLINE_SINGLE:
case UNDERLINE_DOUBLE:
case UNDERLINE_CURLY:
case UNDERLINE_DOTTED:
case UNDERLINE_DASHED:
term->vt.underline.style = style;
term->bits_affecting_ascii_printer.underline_style =
style > UNDERLINE_SINGLE;
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
break;
}
term_update_ascii_printer(term);
}
break;
}
csi: add back 'blink' attribute
2019-07-16 13:19:17 +02:00
case 5: term->vt.attrs.blink = true; break;
csi: add 'unimplemented' warnings for things we handle but ignore
2019-08-04 18:11:59 +02:00
case 6: LOG_WARN("ignored: rapid blink"); break;
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
case 7: term->vt.attrs.reverse = true; break;
case 8: term->vt.attrs.conceal = true; break;
case 9: term->vt.attrs.strikethrough = true; break;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
csi: implement SGR 21, double underlines
2024-07-02 07:45:04 +02:00
case 21:
term->vt.attrs.underline = true;
term->vt.underline.style = UNDERLINE_DOUBLE;
term->bits_affecting_ascii_printer.underline_style = true;
term_update_ascii_printer(term);
break;
csi: move 'dim' attribute from 'vt' to cell attributes
2019-07-16 13:25:45 +02:00
case 22: term->vt.attrs.bold = term->vt.attrs.dim = false; break;
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
case 23: term->vt.attrs.italic = false; break;
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
case 24: {
term->vt.attrs.underline = false;
Rename various uses of "curly" in the source code with "underline" Since "curly" could make it seem as if all underline styles are curled (to people unfamiliar with the codebase), whereas in reality only 1 is.
2024-07-01 20:00:16 +01:00
term->vt.underline.style = UNDERLINE_NONE;
term->bits_affecting_ascii_printer.underline_style = false;
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
term_update_ascii_printer(term);
break;
}
csi: add back 'blink' attribute
2019-07-16 13:19:17 +02:00
case 25: term->vt.attrs.blink = false; break;
terminal: remove 'blink' attribute from cell struct This makes the other attribute bits fit in a single uint8_t, which makes each cell smaller which improves cache usage.
2019-07-10 18:45:12 +02:00
case 26: break; /* rapid blink, ignored */
vt: cell now tracks attributes (bold, italic, underline etc)
2019-06-16 16:44:42 +02:00
case 27: term->vt.attrs.reverse = false; break;
case 28: term->vt.attrs.conceal = false; break;
case 29: term->vt.attrs.strikethrough = false; break;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
csi: dummy implementation of bright foreground/background colors Re-use the regular colors for now
2019-06-19 11:12:45 +02:00
/* Regular foreground colors */
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
term: track cell color source Each cell now tracks it’s current color source: * default fg/bg * base16 fg/bg (maps to *both* the regular and bright colors) * base256 fg/bg * RGB Note that we don’t have enough bits to separate the regular from the bright colors. These _shouldn’t_ be the same, so we ought to be fine...
2021-11-20 16:29:57 +01:00
term->vt.attrs.fg_src = COLOR_BASE16;
csi: store color index, not actual color, in cell’s fg/bg attributes When using indexed colors (i.e. SGR 30/40/90/100), store the index into the cell’s fg/bg attributes, not the actual color value. This has a couple of consequences: Color table lookup is now done when rendering. This means a rendered cell will always reflect the *current* color table, not the color table that was in use when the cell was printed to. This simplifies the OSC-4/104 logic, since we no longer need to update the grid - we just have to damage it to trigger rendering. Furthermore, this change simplifies the VT parsing, since we no longer need to do any memory loads (except loading the SGR parameter values), only writes.
2021-12-25 17:13:50 +01:00
term->vt.attrs.fg = param - 30;
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
break;
csi: reduce duplication in code handling SGR 38 and 48 sequences
2022-03-22 23:06:22 +00:00
case 38:
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
case 48:
case 58: {
csi: reduce duplication in code handling SGR 38 and 48 sequences
2022-03-22 23:06:22 +00:00
uint32_t color;
enum color_source src;
csi: don't ignore the color space identifier in SGRs Only a color space ID of '2' means the sequence is an RGB sequence. Update existing code to verify this, and ignore sequences with other color space IDs. Except color space ID '5', which is the same as a regular 38;5;<idx> sequence, but using sub-parameters instead (38:2:5:<idx>).
2019-09-04 20:28:35 +02:00
/* Indexed: 38;5;<idx> */
csi: fix parsing of 256-color and 24-bit color SGRs There may be more SGR sequences after the 256-color/24-bit sequence. Thus, check that we have *enough* parameters to parse the 256-color/24-bit SGR. It doesn't have to be *exactly* the required number of parameters though. Fixes issues with sequences like: \e[38;2;1;48;2;1m
2019-07-04 09:57:02 +02:00
if (term->vt.params.idx - i - 1 >= 2 &&
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
term->vt.params.v[i + 1].value == 5)
{
csi: reduce duplication in code handling SGR 38 and 48 sequences
2022-03-22 23:06:22 +00:00
src = COLOR_BASE256;
csi: clamp color index for ‘CSI 38/48 ; 5 ; idx m’ sequences Indexed color values are stored in the cell attributes as color indices (into the 256-color table). However, the index from the CSI was not validated in any way, meaning you can do something like this: echo -e ‘\e[38:5:1024m CRASH \e[m’ and foot will crash on an out-of-bounds access. Fix by clamping the color index. Closes #1111
2022-07-22 10:44:33 +02:00
color = min(term->vt.params.v[i + 2].value,
ALEN(term->colors.table) - 1);
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
i += 2;
csi: implement ':'-separated 24-bit color values
2019-07-15 12:35:43 +02:00
}
csi: don't ignore the color space identifier in SGRs Only a color space ID of '2' means the sequence is an RGB sequence. Update existing code to verify this, and ignore sequences with other color space IDs. Except color space ID '5', which is the same as a regular 38;5;<idx> sequence, but using sub-parameters instead (38:2:5:<idx>).
2019-09-04 20:28:35 +02:00
/* RGB: 38;2;<r>;<g>;<b> */
csi: implement ':'-separated 24-bit color values
2019-07-15 12:35:43 +02:00
else if (term->vt.params.idx - i - 1 >= 4 &&
term->vt.params.v[i + 1].value == 2)
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
{
colors: store as doubles, rather than uint32_t Since cairo uses doubles, we don't want to have to convert a uin32_t to double values every time we render a cell.
2019-06-26 20:33:32 +02:00
uint8_t r = term->vt.params.v[i + 2].value;
uint8_t g = term->vt.params.v[i + 3].value;
uint8_t b = term->vt.params.v[i + 4].value;
csi: reduce duplication in code handling SGR 38 and 48 sequences
2022-03-22 23:06:22 +00:00
src = COLOR_RGB;
color = r << 16 | g << 8 | b;
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
i += 4;
csi: implement ':'-separated 24-bit color values
2019-07-15 12:35:43 +02:00
}
csi: fix sub-parameter versions of 38/48 SGR escapes Well this is embarrassing; the sub-parameter versions of the 38/48 SGR escapes all required an extra ‘:2’ that wasn’t supposed to be there, causing all the other sub-parameters to be shifted one step to the right. That is, foot expected e.g. 38:2:2:r:g:b, or 38:2:5:idx when the correct sequences are 38:2:cs:r:g:b and 38:5:idx. I.e. I mixed up the color-space ID (cs) of 38:2 with *type* of color: RGB or indexed. In addition to fixing this, this patch also adds support for a “bastard” version of the sub-parameter based RGB escapes, where the color-space identifier has been left out: e.g. 38:2:r:g:b. This sequence is invalid, but applications tend to “forget” the color-space ID...
2020-12-12 20:50:43 +01:00
/* Indexed: 38:5:<idx> */
csi: don't ignore the color space identifier in SGRs Only a color space ID of '2' means the sequence is an RGB sequence. Update existing code to verify this, and ignore sequences with other color space IDs. Except color space ID '5', which is the same as a regular 38;5;<idx> sequence, but using sub-parameters instead (38:2:5:<idx>).
2019-09-04 20:28:35 +02:00
else if (term->vt.params.v[i].sub.idx >= 2 &&
csi: fix sub-parameter versions of 38/48 SGR escapes Well this is embarrassing; the sub-parameter versions of the 38/48 SGR escapes all required an extra ‘:2’ that wasn’t supposed to be there, causing all the other sub-parameters to be shifted one step to the right. That is, foot expected e.g. 38:2:2:r:g:b, or 38:2:5:idx when the correct sequences are 38:2:cs:r:g:b and 38:5:idx. I.e. I mixed up the color-space ID (cs) of 38:2 with *type* of color: RGB or indexed. In addition to fixing this, this patch also adds support for a “bastard” version of the sub-parameter based RGB escapes, where the color-space identifier has been left out: e.g. 38:2:r:g:b. This sequence is invalid, but applications tend to “forget” the color-space ID...
2020-12-12 20:50:43 +01:00
term->vt.params.v[i].sub.value[0] == 5)
{
csi: reduce duplication in code handling SGR 38 and 48 sequences
2022-03-22 23:06:22 +00:00
src = COLOR_BASE256;
csi: clamp color index for ‘CSI 38/48 ; 5 ; idx m’ sequences Indexed color values are stored in the cell attributes as color indices (into the 256-color table). However, the index from the CSI was not validated in any way, meaning you can do something like this: echo -e ‘\e[38:5:1024m CRASH \e[m’ and foot will crash on an out-of-bounds access. Fix by clamping the color index. Closes #1111
2022-07-22 10:44:33 +02:00
color = min(term->vt.params.v[i].sub.value[1],
ALEN(term->colors.table) - 1);
csi: fix sub-parameter versions of 38/48 SGR escapes Well this is embarrassing; the sub-parameter versions of the 38/48 SGR escapes all required an extra ‘:2’ that wasn’t supposed to be there, causing all the other sub-parameters to be shifted one step to the right. That is, foot expected e.g. 38:2:2:r:g:b, or 38:2:5:idx when the correct sequences are 38:2:cs:r:g:b and 38:5:idx. I.e. I mixed up the color-space ID (cs) of 38:2 with *type* of color: RGB or indexed. In addition to fixing this, this patch also adds support for a “bastard” version of the sub-parameter based RGB escapes, where the color-space identifier has been left out: e.g. 38:2:r:g:b. This sequence is invalid, but applications tend to “forget” the color-space ID...
2020-12-12 20:50:43 +01:00
}
/*
* RGB: 38:2:<color-space>:r:g:b[:ignored:tolerance:tolerance-color-space]
* RGB: 38:2:r:g:b
*
* The second version is a "bastard" version - many
* programs "forget" the color space ID
* parameter... *sigh*
*/
else if (term->vt.params.v[i].sub.idx >= 4 &&
csi: don't ignore the color space identifier in SGRs Only a color space ID of '2' means the sequence is an RGB sequence. Update existing code to verify this, and ignore sequences with other color space IDs. Except color space ID '5', which is the same as a regular 38;5;<idx> sequence, but using sub-parameters instead (38:2:5:<idx>).
2019-09-04 20:28:35 +02:00
term->vt.params.v[i].sub.value[0] == 2)
{
csi: implement ':'-separated 24-bit color values
2019-07-15 12:35:43 +02:00
const struct vt_param *param = &term->vt.params.v[i];
csi: fix sub-parameter versions of 38/48 SGR escapes Well this is embarrassing; the sub-parameter versions of the 38/48 SGR escapes all required an extra ‘:2’ that wasn’t supposed to be there, causing all the other sub-parameters to be shifted one step to the right. That is, foot expected e.g. 38:2:2:r:g:b, or 38:2:5:idx when the correct sequences are 38:2:cs:r:g:b and 38:5:idx. I.e. I mixed up the color-space ID (cs) of 38:2 with *type* of color: RGB or indexed. In addition to fixing this, this patch also adds support for a “bastard” version of the sub-parameter based RGB escapes, where the color-space identifier has been left out: e.g. 38:2:r:g:b. This sequence is invalid, but applications tend to “forget” the color-space ID...
2020-12-12 20:50:43 +01:00
bool have_color_space_id = param->sub.idx >= 5;
/* 0 - color space (ignored) */
int r_idx = 2 - !have_color_space_id;
int g_idx = 3 - !have_color_space_id;
int b_idx = 4 - !have_color_space_id;
/* 5 - unused */
/* 6 - CS tolerance */
/* 7 - color space associated with tolerance */
uint8_t r = param->sub.value[r_idx];
uint8_t g = param->sub.value[g_idx];
uint8_t b = param->sub.value[b_idx];
csi: reduce duplication in code handling SGR 38 and 48 sequences
2022-03-22 23:06:22 +00:00
src = COLOR_RGB;
color = r << 16 | g << 8 | b;
csi: implement ':'-separated 24-bit color values
2019-07-15 12:35:43 +02:00
}
csi: fix sub-parameter versions of 38/48 SGR escapes Well this is embarrassing; the sub-parameter versions of the 38/48 SGR escapes all required an extra ‘:2’ that wasn’t supposed to be there, causing all the other sub-parameters to be shifted one step to the right. That is, foot expected e.g. 38:2:2:r:g:b, or 38:2:5:idx when the correct sequences are 38:2:cs:r:g:b and 38:5:idx. I.e. I mixed up the color-space ID (cs) of 38:2 with *type* of color: RGB or indexed. In addition to fixing this, this patch also adds support for a “bastard” version of the sub-parameter based RGB escapes, where the color-space identifier has been left out: e.g. 38:2:r:g:b. This sequence is invalid, but applications tend to “forget” the color-space ID...
2020-12-12 20:50:43 +01:00
/* Transparent: 38:1 */
/* CMY: 38:3:<color-space>:c:m:y[:tolerance:tolerance-color-space] */
/* CMYK: 38:4:<color-space>:c:m:y:k[:tolerance:tolerance-color-space] */
csi: don't ignore the color space identifier in SGRs Only a color space ID of '2' means the sequence is an RGB sequence. Update existing code to verify this, and ignore sequences with other color space IDs. Except color space ID '5', which is the same as a regular 38;5;<idx> sequence, but using sub-parameters instead (38:2:5:<idx>).
2019-09-04 20:28:35 +02:00
/* Unrecognized */
csi: reduce duplication in code handling SGR 38 and 48 sequences
2022-03-22 23:06:22 +00:00
else {
csi: log only the un-handled parameter in a multi-operation CSI Assume we don't handle 'CSI 4 X'. Furthermore, assume we receive the following: 'CSI 1;2;3;4X'. In this case, only log '4X' as un-handled, not the entire CSI string.
2020-02-01 19:42:31 +01:00
UNHANDLED_SGR(i);
csi: reduce duplication in code handling SGR 38 and 48 sequences
2022-03-22 23:06:22 +00:00
break;
}
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
if (unlikely(param == 58)) {
Rename various uses of "curly" in the source code with "underline" Since "curly" could make it seem as if all underline styles are curled (to people unfamiliar with the codebase), whereas in reality only 1 is.
2024-07-01 20:00:16 +01:00
term->vt.underline.color_src = src;
term->vt.underline.color = color;
term->bits_affecting_ascii_printer.underline_color = true;
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
term_update_ascii_printer(term);
} else if (param == 38) {
csi: reduce duplication in code handling SGR 38 and 48 sequences
2022-03-22 23:06:22 +00:00
term->vt.attrs.fg_src = src;
term->vt.attrs.fg = color;
} else {
xassert(param == 48);
term->vt.attrs.bg_src = src;
term->vt.attrs.bg = color;
}
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
break;
}
csi: implement ':'-separated 24-bit color values
2019-07-15 12:35:43 +02:00
grid: attributes now track whether we've set a foreground/background color This means we don't have to explicitly set the foreground/background to the grid's default colors whenever we reset/clear a cell, and we can instead simply memset() the entire cell to 0. This also means the renderer has to get the default color when rendering a cell without a foreground/background color set.
2019-06-26 19:44:31 +02:00
case 39:
term: track cell color source Each cell now tracks it’s current color source: * default fg/bg * base16 fg/bg (maps to *both* the regular and bright colors) * base256 fg/bg * RGB Note that we don’t have enough bits to separate the regular from the bright colors. These _shouldn’t_ be the same, so we ought to be fine...
2021-11-20 16:29:57 +01:00
term->vt.attrs.fg_src = COLOR_DEFAULT;
grid: attributes now track whether we've set a foreground/background color This means we don't have to explicitly set the foreground/background to the grid's default colors whenever we reset/clear a cell, and we can instead simply memset() the entire cell to 0. This also means the renderer has to get the default color when rendering a cell without a foreground/background color set.
2019-06-26 19:44:31 +02:00
break;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
csi: dummy implementation of bright foreground/background colors Re-use the regular colors for now
2019-06-19 11:12:45 +02:00
/* Regular background colors */
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
term: track cell color source Each cell now tracks it’s current color source: * default fg/bg * base16 fg/bg (maps to *both* the regular and bright colors) * base256 fg/bg * RGB Note that we don’t have enough bits to separate the regular from the bright colors. These _shouldn’t_ be the same, so we ought to be fine...
2021-11-20 16:29:57 +01:00
term->vt.attrs.bg_src = COLOR_BASE16;
csi: store color index, not actual color, in cell’s fg/bg attributes When using indexed colors (i.e. SGR 30/40/90/100), store the index into the cell’s fg/bg attributes, not the actual color value. This has a couple of consequences: Color table lookup is now done when rendering. This means a rendered cell will always reflect the *current* color table, not the color table that was in use when the cell was printed to. This simplifies the OSC-4/104 logic, since we no longer need to update the grid - we just have to damage it to trigger rendering. Furthermore, this change simplifies the VT parsing, since we no longer need to do any memory loads (except loading the SGR parameter values), only writes.
2021-12-25 17:13:50 +01:00
term->vt.attrs.bg = param - 40;
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
break;
grid: attributes now track whether we've set a foreground/background color This means we don't have to explicitly set the foreground/background to the grid's default colors whenever we reset/clear a cell, and we can instead simply memset() the entire cell to 0. This also means the renderer has to get the default color when rendering a cell without a foreground/background color set.
2019-06-26 19:44:31 +02:00
case 49:
term: track cell color source Each cell now tracks it’s current color source: * default fg/bg * base16 fg/bg (maps to *both* the regular and bright colors) * base256 fg/bg * RGB Note that we don’t have enough bits to separate the regular from the bright colors. These _shouldn’t_ be the same, so we ought to be fine...
2021-11-20 16:29:57 +01:00
term->vt.attrs.bg_src = COLOR_DEFAULT;
grid: attributes now track whether we've set a foreground/background color This means we don't have to explicitly set the foreground/background to the grid's default colors whenever we reset/clear a cell, and we can instead simply memset() the entire cell to 0. This also means the renderer has to get the default color when rendering a cell without a foreground/background color set.
2019-06-26 19:44:31 +02:00
break;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
case 59:
Rename various uses of "curly" in the source code with "underline" Since "curly" could make it seem as if all underline styles are curled (to people unfamiliar with the codebase), whereas in reality only 1 is.
2024-07-01 20:00:16 +01:00
term->vt.underline.color_src = COLOR_DEFAULT;
term->vt.underline.color = 0;
term->bits_affecting_ascii_printer.underline_color = false;
csi: wip: styled underlines This is work in progress, and fairly untested. This adds initial tracking of styled underlines. Setting attributes seems to work (both color and underline style). Grid reflow has *not* been tested. When rendering, style is currently ignored (all styles are rendered as a plain, legacy underline). Color however, *is* applied.
2024-06-23 17:39:15 +02:00
term_update_ascii_printer(term);
break;
csi: dummy implementation of bright foreground/background colors Re-use the regular colors for now
2019-06-19 11:12:45 +02:00
/* Bright foreground colors */
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
case 90:
case 91:
case 92:
case 93:
case 94:
case 95:
case 96:
case 97:
term: track cell color source Each cell now tracks it’s current color source: * default fg/bg * base16 fg/bg (maps to *both* the regular and bright colors) * base256 fg/bg * RGB Note that we don’t have enough bits to separate the regular from the bright colors. These _shouldn’t_ be the same, so we ought to be fine...
2021-11-20 16:29:57 +01:00
term->vt.attrs.fg_src = COLOR_BASE16;
csi: store color index, not actual color, in cell’s fg/bg attributes When using indexed colors (i.e. SGR 30/40/90/100), store the index into the cell’s fg/bg attributes, not the actual color value. This has a couple of consequences: Color table lookup is now done when rendering. This means a rendered cell will always reflect the *current* color table, not the color table that was in use when the cell was printed to. This simplifies the OSC-4/104 logic, since we no longer need to update the grid - we just have to damage it to trigger rendering. Furthermore, this change simplifies the VT parsing, since we no longer need to do any memory loads (except loading the SGR parameter values), only writes.
2021-12-25 17:13:50 +01:00
term->vt.attrs.fg = param - 90 + 8;
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
break;
csi: dummy implementation of bright foreground/background colors Re-use the regular colors for now
2019-06-19 11:12:45 +02:00
term: use colors256 array for *all* colors That is, remove the 'regular' and 'bright' color arrays. This is possible since the 256-color array is defined such that the first 16 colors map to the regular and bright colors.
2019-08-21 18:47:48 +02:00
/* Bright background colors */
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
case 100:
case 101:
case 102:
case 103:
case 104:
case 105:
case 106:
case 107:
term: track cell color source Each cell now tracks it’s current color source: * default fg/bg * base16 fg/bg (maps to *both* the regular and bright colors) * base256 fg/bg * RGB Note that we don’t have enough bits to separate the regular from the bright colors. These _shouldn’t_ be the same, so we ought to be fine...
2021-11-20 16:29:57 +01:00
term->vt.attrs.bg_src = COLOR_BASE16;
csi: store color index, not actual color, in cell’s fg/bg attributes When using indexed colors (i.e. SGR 30/40/90/100), store the index into the cell’s fg/bg attributes, not the actual color value. This has a couple of consequences: Color table lookup is now done when rendering. This means a rendered cell will always reflect the *current* color table, not the color table that was in use when the cell was printed to. This simplifies the OSC-4/104 logic, since we no longer need to update the grid - we just have to damage it to trigger rendering. Furthermore, this change simplifies the VT parsing, since we no longer need to do any memory loads (except loading the SGR parameter values), only writes.
2021-12-25 17:13:50 +01:00
term->vt.attrs.bg = param - 100 + 8;
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
break;
csi: dummy implementation of bright foreground/background colors Re-use the regular colors for now
2019-06-19 11:12:45 +02:00
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
default:
csi: log only the un-handled parameter in a multi-operation CSI Assume we don't handle 'CSI 4 X'. Furthermore, assume we receive the following: 'CSI 1;2;3;4X'. In this case, only log '4X' as un-handled, not the entire CSI string.
2020-02-01 19:42:31 +01:00
UNHANDLED_SGR(i);
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
break;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
}
}
}
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
static void
decset_decrst(struct terminal *term, unsigned param, bool enable)
{
#if defined(_DEBUG)
/* For UNHANDLED() */
int UNUSED final = enable ? 'h' : 'l';
#endif
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
/* Note: update XTSAVE/XTRESTORE if adding/removing things here */
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
switch (param) {
case 1:
csi: add DEC names to a couple of DECSET modes
2020-08-16 16:25:52 +02:00
/* DECCKM */
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term->cursor_keys_mode =
enable ? CURSOR_KEYS_APPLICATION : CURSOR_KEYS_NORMAL;
break;
case 5:
csi: add DEC names to a couple of DECSET modes
2020-08-16 16:25:52 +02:00
/* DECSCNM */
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term->reverse = enable;
term_damage_all(term);
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
term_damage_margins(term);
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
break;
csi: add DEC names to a couple of DECSET modes
2020-08-16 16:25:52 +02:00
case 6: {
/* DECOM */
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term->origin = enable ? ORIGIN_RELATIVE : ORIGIN_ABSOLUTE;
term_cursor_home(term);
break;
}
case 7:
/* DECAWM */
term->auto_margin = enable;
term->grid->cursor.lcf = false;
break;
case 9:
if (enable)
LOG_WARN("unimplemented: X10 mouse tracking mode");
csi: decset/decrst: only clear mouse tracking/reporting if mode matches E.g. only set mouse reporting to NONE, if mouse reporting mode is SGR and an DECRST SGR is issued. Do *not* reset the mouse mode if e.g. mouse reporting mode is SGR and an DECRST URXVT is issued.
2020-08-18 06:53:47 +02:00
#if 0
else if (term->mouse_tracking == MOUSE_X10)
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term->mouse_tracking = MOUSE_NONE;
csi: decset/decrst: only clear mouse tracking/reporting if mode matches E.g. only set mouse reporting to NONE, if mouse reporting mode is SGR and an DECRST SGR is issued. Do *not* reset the mouse mode if e.g. mouse reporting mode is SGR and an DECRST URXVT is issued.
2020-08-18 06:53:47 +02:00
#endif
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
break;
case 12:
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
term->cursor_blink.decset = enable;
term_cursor_blink_update(term);
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
break;
case 25:
csi: add DEC names to a couple of DECSET modes
2020-08-16 16:25:52 +02:00
/* DECTCEM */
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term->hide_cursor = !enable;
break;
term: add private mode flag ‘’reverse-wrap’
2020-10-01 20:15:32 +02:00
case 45:
term->reverse_wrap = enable;
break;
csi: add support for DECNKM private mode This is equivalent to DECKPAM/DECKPNM when enabled/disabled, but can also be saved/restored/queried with XTSAVE/XTRESTORE/DECRQM. See also: * https://vt100.net/docs/vt510-rm/DECNKM.html * https://vt100.net/docs/vt510-rm/DECKPAM.html * https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-PC-Style-Function-Keys
2022-03-19 13:14:54 +00:00
case 66:
/* DECNKM */
term->keypad_keys_mode = enable ? KEYPAD_APPLICATION : KEYPAD_NUMERICAL;
break;
csi: indicate "permanently reset" for DECRQM queries of mode 67 (DECBKM) This allows dynamic querying for the equivalent of terminfo's "kbs" capability.
2024-03-15 17:51:51 +00:00
case 67:
if (enable)
LOG_WARN("unimplemented: DECBKM");
break;
sixel: implement private mode 80 - sixel scrolling When enabled (the default), sixels behave much like normal output; the start where the cursor is, and the cursor moves with the sixel. I.e. after emitting a sixel the cursor is left after the image; either to the right, if private mode 8452 is enabled, or otherwise on the next line. Terminal content is scrolled up if the sixel is larger than the screen. When disabled, sixels *always* start at (0,0), the cursor never moves, and the terminal content never scrolls. In other words, the ‘disabled’ mode is a much simpler mode. All we need to do to support both modes is re-write the sixel-emitting loop to: * break early if we’re “out of rows”, i.e. we’ve reached the bottom of the screen. * not linefeed, or move the cursor when scrolling is disabled This patch also fixes a bug in the (new) implementation of private mode 8452. When emitting a sixel, we may break it up into smaller pieces, to ensure a single sixel (as tracked internally) does not cross the scrollback wrap-around. The code that checked if we should do a linefeed or not, would skip the linefeed on the last row of *each* such sixel piece. The correct thing to do is to skip it only on the last row of the *last* piece. I chose not to fix this bug in a separate patch since doing so would have meant re-writing it again when implementing private mode 80.
2021-02-26 09:28:03 +01:00
case 80:
csi: invert the meaning of DECSDM There has been some confusion whether enabling DECSDM (private mode 80) enables or disables sixel scrolling. Foot currently enables scrolling when DECSDM is set, and this patch changes this, such that setting DECSDM now *disables* scrolling. The confusion is apparently due to a documentation error in the VT340 manual, as described in https://github.com/dankamongmen/notcurses/issues/1782#issuecomment-863603641. And that makes sense, in a way: the SDM in DECSDM stands for Sixel Display Mode. I.e. it stands to reason that enabling that disables scrolling. Anyway, this lead to https://github.com/hackerb9/lsix/issues/41, where it was eventually proven (by testing on a real VT340), that foot, and a large number of other terminals (including XTerm) has it wrong: https://github.com/hackerb9/lsix/issues/41#issuecomment-873269599.
2021-07-14 19:17:44 +02:00
term->sixel.scrolling = !enable;
sixel: implement private mode 80 - sixel scrolling When enabled (the default), sixels behave much like normal output; the start where the cursor is, and the cursor moves with the sixel. I.e. after emitting a sixel the cursor is left after the image; either to the right, if private mode 8452 is enabled, or otherwise on the next line. Terminal content is scrolled up if the sixel is larger than the screen. When disabled, sixels *always* start at (0,0), the cursor never moves, and the terminal content never scrolls. In other words, the ‘disabled’ mode is a much simpler mode. All we need to do to support both modes is re-write the sixel-emitting loop to: * break early if we’re “out of rows”, i.e. we’ve reached the bottom of the screen. * not linefeed, or move the cursor when scrolling is disabled This patch also fixes a bug in the (new) implementation of private mode 8452. When emitting a sixel, we may break it up into smaller pieces, to ensure a single sixel (as tracked internally) does not cross the scrollback wrap-around. The code that checked if we should do a linefeed or not, would skip the linefeed on the last row of *each* such sixel piece. The correct thing to do is to skip it only on the last row of the *last* piece. I chose not to fix this bug in a separate patch since doing so would have meant re-writing it again when implementing private mode 80.
2021-02-26 09:28:03 +01:00
break;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
case 1000:
csi: decset/decrst: only clear mouse tracking/reporting if mode matches E.g. only set mouse reporting to NONE, if mouse reporting mode is SGR and an DECRST SGR is issued. Do *not* reset the mouse mode if e.g. mouse reporting mode is SGR and an DECRST URXVT is issued.
2020-08-18 06:53:47 +02:00
if (enable)
term->mouse_tracking = MOUSE_CLICK;
else if (term->mouse_tracking == MOUSE_CLICK)
term->mouse_tracking = MOUSE_NONE;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term_xcursor_update(term);
break;
case 1001:
if (enable)
LOG_WARN("unimplemented: highlight mouse tracking");
break;
case 1002:
csi: decset/decrst: only clear mouse tracking/reporting if mode matches E.g. only set mouse reporting to NONE, if mouse reporting mode is SGR and an DECRST SGR is issued. Do *not* reset the mouse mode if e.g. mouse reporting mode is SGR and an DECRST URXVT is issued.
2020-08-18 06:53:47 +02:00
if (enable)
term->mouse_tracking = MOUSE_DRAG;
else if (term->mouse_tracking == MOUSE_DRAG)
term->mouse_tracking = MOUSE_NONE;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term_xcursor_update(term);
break;
case 1003:
csi: decset/decrst: only clear mouse tracking/reporting if mode matches E.g. only set mouse reporting to NONE, if mouse reporting mode is SGR and an DECRST SGR is issued. Do *not* reset the mouse mode if e.g. mouse reporting mode is SGR and an DECRST URXVT is issued.
2020-08-18 06:53:47 +02:00
if (enable)
term->mouse_tracking = MOUSE_MOTION;
else if (term->mouse_tracking == MOUSE_MOTION)
term->mouse_tracking = MOUSE_NONE;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term_xcursor_update(term);
break;
case 1004:
term->focus_events = enable;
break;
case 1005:
if (enable)
LOG_WARN("unimplemented: mouse reporting mode: UTF-8");
csi: decset/decrst: only clear mouse tracking/reporting if mode matches E.g. only set mouse reporting to NONE, if mouse reporting mode is SGR and an DECRST SGR is issued. Do *not* reset the mouse mode if e.g. mouse reporting mode is SGR and an DECRST URXVT is issued.
2020-08-18 06:53:47 +02:00
#if 0
else if (term->mouse_reporting == MOUSE_UTF8)
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term->mouse_reporting = MOUSE_NONE;
csi: decset/decrst: only clear mouse tracking/reporting if mode matches E.g. only set mouse reporting to NONE, if mouse reporting mode is SGR and an DECRST SGR is issued. Do *not* reset the mouse mode if e.g. mouse reporting mode is SGR and an DECRST URXVT is issued.
2020-08-18 06:53:47 +02:00
#endif
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
break;
case 1006:
if (enable)
csi: decset/decrst: only clear mouse tracking/reporting if mode matches E.g. only set mouse reporting to NONE, if mouse reporting mode is SGR and an DECRST SGR is issued. Do *not* reset the mouse mode if e.g. mouse reporting mode is SGR and an DECRST URXVT is issued.
2020-08-18 06:53:47 +02:00
term->mouse_reporting = MOUSE_SGR;
else if (term->mouse_reporting == MOUSE_SGR)
term->mouse_reporting = MOUSE_NORMAL;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
break;
case 1007:
term->alt_scrolling = enable;
break;
case 1015:
if (enable)
csi: decset/decrst: only clear mouse tracking/reporting if mode matches E.g. only set mouse reporting to NONE, if mouse reporting mode is SGR and an DECRST SGR is issued. Do *not* reset the mouse mode if e.g. mouse reporting mode is SGR and an DECRST URXVT is issued.
2020-08-18 06:53:47 +02:00
term->mouse_reporting = MOUSE_URXVT;
else if (term->mouse_reporting == MOUSE_URXVT)
term->mouse_reporting = MOUSE_NORMAL;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
break;
SGR-Pixels mouse mode, closes #762
2021-12-30 05:13:45 -06:00
case 1016:
if (enable)
term->mouse_reporting = MOUSE_SGR_PIXELS;
else if (term->mouse_reporting == MOUSE_SGR_PIXELS)
term->mouse_reporting = MOUSE_NORMAL;
break;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
case 1034:
/* smm */
LOG_DBG("%s 8-bit meta mode", enable ? "enabling" : "disabling");
term->meta.eight_bit = enable;
break;
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
case 1035:
/* numLock */
LOG_DBG("%s Num Lock modifier", enable ? "enabling" : "disabling");
term->num_lock_modifier = enable;
break;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
case 1036:
/* metaSendsEscape */
LOG_DBG("%s meta-sends-escape", enable ? "enabling" : "disabling");
term->meta.esc_prefix = enable;
break;
case 1042:
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
term->bell_action_enabled = enable;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
break;
csi: implement ‘CSI ? 1042 h/l’ - enable/disable bell-is-urgent
2020-10-11 17:44:29 +02:00
#if 0
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
case 1043:
LOG_WARN("unimplemented: raise window on ctrl-g");
break;
#endif
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
case 1048:
if (enable)
term_save_cursor(term);
else
term_restore_cursor(term, &term->grid->saved_cursor);
break;
csi: implement DECSET 47 - use alternate screen buffer
2021-01-16 13:34:40 +01:00
case 47:
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
case 1047:
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
case 1049:
if (enable && term->grid != &term->alt) {
selection_cancel(term);
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
if (param == 1049)
term_save_cursor(term);
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term->grid = &term->alt;
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
/* Cursor retains its position from the normal grid */
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term_cursor_to(
term,
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
min(term->normal.cursor.point.row, term->rows - 1),
min(term->normal.cursor.point.col, term->cols - 1));
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
tll_free(term->normal.scroll_damage);
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
term_erase(term, 0, 0, term->rows - 1, term->cols - 1);
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
}
else if (!enable && term->grid == &term->alt) {
selection_cancel(term);
term->grid = &term->normal;
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
/* Cursor retains its position from the alt grid */
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term_cursor_to(
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
term, min(term->alt.cursor.point.row, term->rows - 1),
min(term->alt.cursor.point.col, term->cols - 1));
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
if (param == 1049)
term_restore_cursor(term, &term->grid->saved_cursor);
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
/* Delete all sixel images on the alt screen */
tll_foreach(term->alt.sixel_images, it) {
sixel_destroy(&it->item);
tll_remove(term->alt.sixel_images, it);
}
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
tll_free(term->alt.scroll_damage);
csi: damage *viewport* when exiting the alt screen This fixes a redraw issue when the normal screen were somewhere in the scrollback history when exiting the alt screen.
2022-09-06 17:37:19 +02:00
term_damage_view(term);
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
}
term: performance: use a bitfield to track which ascii printer to use The things affecting which ASCII printer we use have grown... Instead of checking everything inside term_update_ascii_printer(), use a bitfield. Anything affecting the printer used, must now set a bit in this bitfield. This makes term_update_ascii_printer() much faster, since all it needs to do is check if the bitfield is zero or not.
2024-06-24 01:26:57 +02:00
term->bits_affecting_ascii_printer.sixels =
tll_length(term->grid->sixel_images) > 0;
csi: update ASCII printer function pointer when switching to/from alt screen This is necessary since switching screen may change how many sixels we have in the scrollback.
2021-03-16 13:07:09 +01:00
term_update_ascii_printer(term);
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
break;
sixel: implement private mode 1070 - private color palette When enabled (the default), sixels use private color registers. That is, the color palette from the last sixel is *not* re-used. When disabled, sixels share (i.e. re-use) the same color palette. Closes #362
2021-02-16 19:37:49 +01:00
case 1070:
term->sixel.use_private_palette = enable;
break;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
case 2004:
term->bracketed_paste = enable;
break;
csi: add support for DECSET 2026, as an alternative to BSU/ESU sequences See: https://gitlab.freedesktop.org/terminal-wg/specifications/-/merge_requests/2#note_847720
2021-04-25 18:35:46 +01:00
case 2026:
if (enable)
term_enable_app_sync_updates(term);
else
term_disable_app_sync_updates(term);
break;
csi: implement DECSET/DECRST/DECRQM 2027 - grapheme cluster processing This implements private mode 2027 - grapheme cluster processing, as defined in the "Terminal Unicode Core"[1] specification. Internally, we just flip the already existing option "grapheme shaping". Since it's now runtime changeable, we need a copy of it in the terminal struct, rather than referencing the conf object. [1]: https://github.com/contour-terminal/terminal-unicode-core/blob/13fc5a8993a033ff10c1f3433d08cb618cde4ac2/spec/terminal-unicode-core.tex#L50-L53
2023-09-20 13:45:06 +02:00
case 2027:
csi: don't allow client app to enable grapheme-shaping when disabled at compile-time Closes #2039
2025-04-19 12:16:48 +02:00
#if defined(FOOT_GRAPHEME_CLUSTERING)
csi: implement DECSET/DECRST/DECRQM 2027 - grapheme cluster processing This implements private mode 2027 - grapheme cluster processing, as defined in the "Terminal Unicode Core"[1] specification. Internally, we just flip the already existing option "grapheme shaping". Since it's now runtime changeable, we need a copy of it in the terminal struct, rather than referencing the conf object. [1]: https://github.com/contour-terminal/terminal-unicode-core/blob/13fc5a8993a033ff10c1f3433d08cb618cde4ac2/spec/terminal-unicode-core.tex#L50-L53
2023-09-20 13:45:06 +02:00
term->grapheme_shaping = enable;
csi: don't allow client app to enable grapheme-shaping when disabled at compile-time Closes #2039
2025-04-19 12:16:48 +02:00
#endif
csi: implement DECSET/DECRST/DECRQM 2027 - grapheme cluster processing This implements private mode 2027 - grapheme cluster processing, as defined in the "Terminal Unicode Core"[1] specification. Internally, we just flip the already existing option "grapheme shaping". Since it's now runtime changeable, we need a copy of it in the terminal struct, rather than referencing the conf object. [1]: https://github.com/contour-terminal/terminal-unicode-core/blob/13fc5a8993a033ff10c1f3433d08cb618cde4ac2/spec/terminal-unicode-core.tex#L50-L53
2023-09-20 13:45:06 +02:00
break;
csi: implement private mode 2031 (dark/light mode detection) * Recognize 'CSI ? 996 n', and respond with - 'CSI ? 997 ; 1 n' if the primary theme is active - 'CSI ? 997 ; 2 n' if the alternative theme is actice * Implement private mode 2031, where changing the color theme (currently only possible via key bindings) causes the terminal to send the same CSI sequences as above. In this context, foot's primary theme is considered dark, and the alternative theme light (since the default theme is dark). Closes #2025
2025-04-20 12:48:37 +02:00
case 2031:
term->report_theme_changes = enable;
break;
csi: in-band window resize notifications, private mode 2048 This implements https://gist.github.com/rockorager/e695fb2924d36b2bcf1fff4a3704bd83, in-band window resize notifications. When user enables private mode 2048 (in-band resize notifications), *always* send current size, even if the mode is already active. This ensures applications can rely on getting a reply from the terminal.
2024-06-30 19:44:17 +02:00
case 2048:
if (enable)
term_enable_size_notifications(term);
else
term_disable_size_notifications(term);
break;
sixel: implement private mode 8452 - cursor positioning after sixel When disabled (the default), the cursor is positioned on a new line after emitting a sixel image. When enabled, the cursor is positioned to the right of the sixel image. Closes #363
2021-02-16 19:11:38 +01:00
case 8452:
term->sixel.cursor_right_of_graphics = enable;
break;
csi: add DECSET 737769 - enables/disables IME input 73 77 69 = I M E
2020-12-04 21:26:38 +01:00
case 737769:
if (enable)
term_ime_enable(term);
url-mode: disable IME mode while URL-mode is active This prevents the IME from stealing "our" key-presses, and thus preventing the user from opening URLs. Closes #1718, hopefully.
2024-05-21 06:18:00 +02:00
else {
csi: add DECSET 737769 - enables/disables IME input 73 77 69 = I M E
2020-12-04 21:26:38 +01:00
term_ime_disable(term);
url-mode: disable IME mode while URL-mode is active This prevents the IME from stealing "our" key-presses, and thus preventing the user from opening URLs. Closes #1718, hopefully.
2024-05-21 06:18:00 +02:00
term->ime_reenable_after_url_mode = false;
}
csi: add DECSET 737769 - enables/disables IME input 73 77 69 = I M E
2020-12-04 21:26:38 +01:00
break;
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
default:
UNHANDLED();
break;
}
}
static void
decset(struct terminal *term, unsigned param)
{
decset_decrst(term, param, true);
}
static void
decrst(struct terminal *term, unsigned param)
{
csi: decrst: spell decset correctly
2020-08-16 16:38:30 +02:00
decset_decrst(term, param, false);
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
}
csi: reply with 4 instead of 2 for DECRQM queries of unsupported modes The status value 4 means "permanently reset", as opposed to 2, which means "reset". The former implies that there's no way to enable the mode because it's unsupported (but recognized). Note: this commit also fixes an unrelated typo in CHANGELOG.md.
2022-09-17 07:17:12 +01:00
/*
* These values represent the current state of a DEC private mode,
* as returned in the DECRPM reply to a DECRQM query.
*/
enum decrpm_status {
DECRPM_NOT_RECOGNIZED = 0,
DECRPM_SET = 1,
DECRPM_RESET = 2,
DECRPM_PERMANENTLY_SET = 3,
DECRPM_PERMANENTLY_RESET = 4,
};
static enum decrpm_status
decrpm(bool enabled)
{
return enabled ? DECRPM_SET : DECRPM_RESET;
}
static enum decrpm_status
decrqm(const struct terminal *term, unsigned param)
csi: implement DECRQM (DEC modes), for real Previously, we always returned ‘2 - reset’, instead of the actual state of the requested mode.
2020-12-16 13:57:40 +01:00
{
switch (param) {
csi: reply with 4 instead of 2 for DECRQM queries of unsupported modes The status value 4 means "permanently reset", as opposed to 2, which means "reset". The former implies that there's no way to enable the mode because it's unsupported (but recognized). Note: this commit also fixes an unrelated typo in CHANGELOG.md.
2022-09-17 07:17:12 +01:00
case 1: return decrpm(term->cursor_keys_mode == CURSOR_KEYS_APPLICATION);
case 5: return decrpm(term->reverse);
case 6: return decrpm(term->origin);
case 7: return decrpm(term->auto_margin);
case 9: return DECRPM_PERMANENTLY_RESET; /* term->mouse_tracking == MOUSE_X10; */
case 12: return decrpm(term->cursor_blink.decset);
case 25: return decrpm(!term->hide_cursor);
case 45: return decrpm(term->reverse_wrap);
case 66: return decrpm(term->keypad_keys_mode == KEYPAD_APPLICATION);
csi: indicate "permanently reset" for DECRQM queries of mode 67 (DECBKM) This allows dynamic querying for the equivalent of terminfo's "kbs" capability.
2024-03-15 17:51:51 +00:00
case 67: return DECRPM_PERMANENTLY_RESET; /* https://vt100.net/docs/vt510-rm/DECBKM */
csi: reply with 4 instead of 2 for DECRQM queries of unsupported modes The status value 4 means "permanently reset", as opposed to 2, which means "reset". The former implies that there's no way to enable the mode because it's unsupported (but recognized). Note: this commit also fixes an unrelated typo in CHANGELOG.md.
2022-09-17 07:17:12 +01:00
case 80: return decrpm(!term->sixel.scrolling);
case 1000: return decrpm(term->mouse_tracking == MOUSE_CLICK);
case 1001: return DECRPM_PERMANENTLY_RESET;
case 1002: return decrpm(term->mouse_tracking == MOUSE_DRAG);
case 1003: return decrpm(term->mouse_tracking == MOUSE_MOTION);
case 1004: return decrpm(term->focus_events);
case 1005: return DECRPM_PERMANENTLY_RESET; /* term->mouse_reporting == MOUSE_UTF8; */
case 1006: return decrpm(term->mouse_reporting == MOUSE_SGR);
case 1007: return decrpm(term->alt_scrolling);
case 1015: return decrpm(term->mouse_reporting == MOUSE_URXVT);
case 1016: return decrpm(term->mouse_reporting == MOUSE_SGR_PIXELS);
case 1034: return decrpm(term->meta.eight_bit);
case 1035: return decrpm(term->num_lock_modifier);
case 1036: return decrpm(term->meta.esc_prefix);
case 1042: return decrpm(term->bell_action_enabled);
csi: add 47+1047 (alt screen) to DECRQM
2021-02-09 20:02:29 +01:00
case 47: /* FALLTHROUGH */
case 1047: /* FALLTHROUGH */
csi: reply with 4 instead of 2 for DECRQM queries of unsupported modes The status value 4 means "permanently reset", as opposed to 2, which means "reset". The former implies that there's no way to enable the mode because it's unsupported (but recognized). Note: this commit also fixes an unrelated typo in CHANGELOG.md.
2022-09-17 07:17:12 +01:00
case 1049: return decrpm(term->grid == &term->alt);
case 1070: return decrpm(term->sixel.use_private_palette);
case 2004: return decrpm(term->bracketed_paste);
case 2026: return decrpm(term->render.app_sync_updates.enabled);
csi: decrqm: 2027: permanently disabled when grapheme-width-method != double-width
2023-09-21 18:28:54 +02:00
case 2027: return term->conf->tweak.grapheme_width_method != GRAPHEME_WIDTH_DOUBLE
? DECRPM_PERMANENTLY_RESET
: decrpm(term->grapheme_shaping);
csi: implement private mode 2031 (dark/light mode detection) * Recognize 'CSI ? 996 n', and respond with - 'CSI ? 997 ; 1 n' if the primary theme is active - 'CSI ? 997 ; 2 n' if the alternative theme is actice * Implement private mode 2031, where changing the color theme (currently only possible via key bindings) causes the terminal to send the same CSI sequences as above. In this context, foot's primary theme is considered dark, and the alternative theme light (since the default theme is dark). Closes #2025
2025-04-20 12:48:37 +02:00
case 2031: return decrpm(term->report_theme_changes);
csi: in-band window resize notifications, private mode 2048 This implements https://gist.github.com/rockorager/e695fb2924d36b2bcf1fff4a3704bd83, in-band window resize notifications. When user enables private mode 2048 (in-band resize notifications), *always* send current size, even if the mode is already active. This ensures applications can rely on getting a reply from the terminal.
2024-06-30 19:44:17 +02:00
case 2048: return decrpm(term->size_notifications);
csi: reply with 4 instead of 2 for DECRQM queries of unsupported modes The status value 4 means "permanently reset", as opposed to 2, which means "reset". The former implies that there's no way to enable the mode because it's unsupported (but recognized). Note: this commit also fixes an unrelated typo in CHANGELOG.md.
2022-09-17 07:17:12 +01:00
case 8452: return decrpm(term->sixel.cursor_right_of_graphics);
case 737769: return decrpm(term_ime_is_enabled(term));
csi: implement DECRQM (DEC modes), for real Previously, we always returned ‘2 - reset’, instead of the actual state of the requested mode.
2020-12-16 13:57:40 +01:00
}
csi: reply with 4 instead of 2 for DECRQM queries of unsupported modes The status value 4 means "permanently reset", as opposed to 2, which means "reset". The former implies that there's no way to enable the mode because it's unsupported (but recognized). Note: this commit also fixes an unrelated typo in CHANGELOG.md.
2022-09-17 07:17:12 +01:00
return DECRPM_NOT_RECOGNIZED;
csi: implement DECRQM (DEC modes), for real Previously, we always returned ‘2 - reset’, instead of the actual state of the requested mode.
2020-12-16 13:57:40 +01:00
}
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
static void
xtsave(struct terminal *term, unsigned param)
{
switch (param) {
csi: xtsave: store modes' SET state, not the current state
2020-08-16 16:57:39 +02:00
case 1: term->xtsave.application_cursor_keys = term->cursor_keys_mode == CURSOR_KEYS_APPLICATION; break;
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
case 5: term->xtsave.reverse = term->reverse; break;
case 6: term->xtsave.origin = term->origin; break;
case 7: term->xtsave.auto_margin = term->auto_margin; break;
csi: xtsave: store modes' SET state, not the current state
2020-08-16 16:57:39 +02:00
case 9: /* term->xtsave.mouse_x10 = term->mouse_tracking == MOUSE_X10; */ break;
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
case 12: term->xtsave.cursor_blink = term->cursor_blink.decset; break;
csi: xtsave: store modes' SET state, not the current state
2020-08-16 16:57:39 +02:00
case 25: term->xtsave.show_cursor = !term->hide_cursor; break;
term: add private mode flag ‘’reverse-wrap’
2020-10-01 20:15:32 +02:00
case 45: term->xtsave.reverse_wrap = term->reverse_wrap; break;
csi: implement DECSET 47 - use alternate screen buffer
2021-01-16 13:34:40 +01:00
case 47: term->xtsave.alt_screen = term->grid == &term->alt; break;
csi: add support for DECNKM private mode This is equivalent to DECKPAM/DECKPNM when enabled/disabled, but can also be saved/restored/queried with XTSAVE/XTRESTORE/DECRQM. See also: * https://vt100.net/docs/vt510-rm/DECNKM.html * https://vt100.net/docs/vt510-rm/DECKPAM.html * https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-PC-Style-Function-Keys
2022-03-19 13:14:54 +00:00
case 66: term->xtsave.application_keypad_keys = term->keypad_keys_mode == KEYPAD_APPLICATION; break;
csi: indicate "permanently reset" for DECRQM queries of mode 67 (DECBKM) This allows dynamic querying for the equivalent of terminfo's "kbs" capability.
2024-03-15 17:51:51 +00:00
case 67: break;
csi: invert the meaning of DECSDM There has been some confusion whether enabling DECSDM (private mode 80) enables or disables sixel scrolling. Foot currently enables scrolling when DECSDM is set, and this patch changes this, such that setting DECSDM now *disables* scrolling. The confusion is apparently due to a documentation error in the VT340 manual, as described in https://github.com/dankamongmen/notcurses/issues/1782#issuecomment-863603641. And that makes sense, in a way: the SDM in DECSDM stands for Sixel Display Mode. I.e. it stands to reason that enabling that disables scrolling. Anyway, this lead to https://github.com/hackerb9/lsix/issues/41, where it was eventually proven (by testing on a real VT340), that foot, and a large number of other terminals (including XTerm) has it wrong: https://github.com/hackerb9/lsix/issues/41#issuecomment-873269599.
2021-07-14 19:17:44 +02:00
case 80: term->xtsave.sixel_display_mode = !term->sixel.scrolling; break;
csi: xtsave: store modes' SET state, not the current state
2020-08-16 16:57:39 +02:00
case 1000: term->xtsave.mouse_click = term->mouse_tracking == MOUSE_CLICK; break;
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
case 1001: break;
csi: xtsave: store modes' SET state, not the current state
2020-08-16 16:57:39 +02:00
case 1002: term->xtsave.mouse_drag = term->mouse_tracking == MOUSE_DRAG; break;
case 1003: term->xtsave.mouse_motion = term->mouse_tracking == MOUSE_MOTION; break;
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
case 1004: term->xtsave.focus_events = term->focus_events; break;
csi: xtsave: store modes' SET state, not the current state
2020-08-16 16:57:39 +02:00
case 1005: /* term->xtsave.mouse_utf8 = term->mouse_reporting == MOUSE_UTF8; */ break;
case 1006: term->xtsave.mouse_sgr = term->mouse_reporting == MOUSE_SGR; break;
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
case 1007: term->xtsave.alt_scrolling = term->alt_scrolling; break;
csi: xtsave: store modes' SET state, not the current state
2020-08-16 16:57:39 +02:00
case 1015: term->xtsave.mouse_urxvt = term->mouse_reporting == MOUSE_URXVT; break;
SGR-Pixels mouse mode, closes #762
2021-12-30 05:13:45 -06:00
case 1016: term->xtsave.mouse_sgr_pixels = term->mouse_reporting == MOUSE_SGR_PIXELS; break;
csi: xtsave: store modes' SET state, not the current state
2020-08-16 16:57:39 +02:00
case 1034: term->xtsave.meta_eight_bit = term->meta.eight_bit; break;
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
case 1035: term->xtsave.num_lock_modifier = term->num_lock_modifier; break;
csi: xtsave: store modes' SET state, not the current state
2020-08-16 16:57:39 +02:00
case 1036: term->xtsave.meta_esc_prefix = term->meta.esc_prefix; break;
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
case 1042: term->xtsave.bell_action_enabled = term->bell_action_enabled; break;
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
case 1047: term->xtsave.alt_screen = term->grid == &term->alt; break;
case 1048: term_save_cursor(term); break;
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
case 1049: term->xtsave.alt_screen = term->grid == &term->alt; break;
sixel: implement private mode 1070 - private color palette When enabled (the default), sixels use private color registers. That is, the color palette from the last sixel is *not* re-used. When disabled, sixels share (i.e. re-use) the same color palette. Closes #362
2021-02-16 19:37:49 +01:00
case 1070: term->xtsave.sixel_private_palette = term->sixel.use_private_palette; break;
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
case 2004: term->xtsave.bracketed_paste = term->bracketed_paste; break;
csi: add support for DECSET 2026, as an alternative to BSU/ESU sequences See: https://gitlab.freedesktop.org/terminal-wg/specifications/-/merge_requests/2#note_847720
2021-04-25 18:35:46 +01:00
case 2026: term->xtsave.app_sync_updates = term->render.app_sync_updates.enabled; break;
csi: implement DECSET/DECRST/DECRQM 2027 - grapheme cluster processing This implements private mode 2027 - grapheme cluster processing, as defined in the "Terminal Unicode Core"[1] specification. Internally, we just flip the already existing option "grapheme shaping". Since it's now runtime changeable, we need a copy of it in the terminal struct, rather than referencing the conf object. [1]: https://github.com/contour-terminal/terminal-unicode-core/blob/13fc5a8993a033ff10c1f3433d08cb618cde4ac2/spec/terminal-unicode-core.tex#L50-L53
2023-09-20 13:45:06 +02:00
case 2027: term->xtsave.grapheme_shaping = term->grapheme_shaping; break;
csi: implement private mode 2031 (dark/light mode detection) * Recognize 'CSI ? 996 n', and respond with - 'CSI ? 997 ; 1 n' if the primary theme is active - 'CSI ? 997 ; 2 n' if the alternative theme is actice * Implement private mode 2031, where changing the color theme (currently only possible via key bindings) causes the terminal to send the same CSI sequences as above. In this context, foot's primary theme is considered dark, and the alternative theme light (since the default theme is dark). Closes #2025
2025-04-20 12:48:37 +02:00
case 2031: term->xtsave.report_theme_changes = term->report_theme_changes; break;
csi: in-band window resize notifications, private mode 2048 This implements https://gist.github.com/rockorager/e695fb2924d36b2bcf1fff4a3704bd83, in-band window resize notifications. When user enables private mode 2048 (in-band resize notifications), *always* send current size, even if the mode is already active. This ensures applications can rely on getting a reply from the terminal.
2024-06-30 19:44:17 +02:00
case 2048: term->xtsave.size_notifications = term->size_notifications; break;
sixel: implement private mode 8452 - cursor positioning after sixel When disabled (the default), the cursor is positioned on a new line after emitting a sixel image. When enabled, the cursor is positioned to the right of the sixel image. Closes #363
2021-02-16 19:11:38 +01:00
case 8452: term->xtsave.sixel_cursor_right_of_graphics = term->sixel.cursor_right_of_graphics; break;
csi: add DECSET 737769 - enables/disables IME input 73 77 69 = I M E
2020-12-04 21:26:38 +01:00
case 737769: term->xtsave.ime = term_ime_is_enabled(term); break;
csi: add xtsave() This function stores the current state of DECSET private modes.
2020-08-16 16:38:57 +02:00
}
}
csi: implement XTRESTORE
2020-08-16 17:02:52 +02:00
static void
xtrestore(struct terminal *term, unsigned param)
{
bool enable;
switch (param) {
csi: xtrestore: add missing break
2020-08-18 21:13:50 +02:00
case 1: enable = term->xtsave.application_cursor_keys; break;
csi: implement XTRESTORE
2020-08-16 17:02:52 +02:00
case 5: enable = term->xtsave.reverse; break;
case 6: enable = term->xtsave.origin; break;
case 7: enable = term->xtsave.auto_margin; break;
case 9: /* enable = term->xtsave.mouse_x10; break; */ return;
csi: xtsave/xtrestore: implement \E[?12s and \E[?12r I.e. save/restore cursor-blink state.
2020-08-18 07:00:26 +02:00
case 12: enable = term->xtsave.cursor_blink; break;
csi: implement XTRESTORE
2020-08-16 17:02:52 +02:00
case 25: enable = term->xtsave.show_cursor; break;
csi: xtrestore: add ‘reverse wrap’
2020-10-03 11:53:03 +02:00
case 45: enable = term->xtsave.reverse_wrap; break;
csi: implement DECSET 47 - use alternate screen buffer
2021-01-16 13:34:40 +01:00
case 47: enable = term->xtsave.alt_screen; break;
csi: add support for DECNKM private mode This is equivalent to DECKPAM/DECKPNM when enabled/disabled, but can also be saved/restored/queried with XTSAVE/XTRESTORE/DECRQM. See also: * https://vt100.net/docs/vt510-rm/DECNKM.html * https://vt100.net/docs/vt510-rm/DECKPAM.html * https://invisible-island.net/xterm/ctlseqs/ctlseqs.html#h3-PC-Style-Function-Keys
2022-03-19 13:14:54 +00:00
case 66: enable = term->xtsave.application_keypad_keys; break;
csi: indicate "permanently reset" for DECRQM queries of mode 67 (DECBKM) This allows dynamic querying for the equivalent of terminfo's "kbs" capability.
2024-03-15 17:51:51 +00:00
case 67: return;
csi: invert the meaning of DECSDM There has been some confusion whether enabling DECSDM (private mode 80) enables or disables sixel scrolling. Foot currently enables scrolling when DECSDM is set, and this patch changes this, such that setting DECSDM now *disables* scrolling. The confusion is apparently due to a documentation error in the VT340 manual, as described in https://github.com/dankamongmen/notcurses/issues/1782#issuecomment-863603641. And that makes sense, in a way: the SDM in DECSDM stands for Sixel Display Mode. I.e. it stands to reason that enabling that disables scrolling. Anyway, this lead to https://github.com/hackerb9/lsix/issues/41, where it was eventually proven (by testing on a real VT340), that foot, and a large number of other terminals (including XTerm) has it wrong: https://github.com/hackerb9/lsix/issues/41#issuecomment-873269599.
2021-07-14 19:17:44 +02:00
case 80: enable = term->xtsave.sixel_display_mode; break;
csi: implement XTRESTORE
2020-08-16 17:02:52 +02:00
case 1000: enable = term->xtsave.mouse_click; break;
case 1001: return;
case 1002: enable = term->xtsave.mouse_drag; break;
case 1003: enable = term->xtsave.mouse_motion; break;
case 1004: enable = term->xtsave.focus_events; break;
case 1005: /* enable = term->xtsave.mouse_utf8; break; */ return;
case 1006: enable = term->xtsave.mouse_sgr; break;
case 1007: enable = term->xtsave.alt_scrolling; break;
case 1015: enable = term->xtsave.mouse_urxvt; break;
SGR-Pixels mouse mode, closes #762
2021-12-30 05:13:45 -06:00
case 1016: enable = term->xtsave.mouse_sgr_pixels; break;
csi: implement XTRESTORE
2020-08-16 17:02:52 +02:00
case 1034: enable = term->xtsave.meta_eight_bit; break;
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
case 1035: enable = term->xtsave.num_lock_modifier; break;
csi: implement XTRESTORE
2020-08-16 17:02:52 +02:00
case 1036: enable = term->xtsave.meta_esc_prefix; break;
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
case 1042: enable = term->xtsave.bell_action_enabled; break;
csi: add support for ?1047 and ?1048 * 1047 enters/leaves the alt screen, but without saving/restoring the cursor. * 1048 saves/restores the cursor * 1049 is 1047+1048 Note: when xtsaving and xtrestoring 1048, why simply save/restore the cursor. Without having read XTerms sources, this appears to be what it is doing.
2021-01-15 17:09:15 +01:00
case 1047: enable = term->xtsave.alt_screen; break;
case 1048: enable = true; break;
csi: implement XTRESTORE
2020-08-16 17:02:52 +02:00
case 1049: enable = term->xtsave.alt_screen; break;
sixel: implement private mode 1070 - private color palette When enabled (the default), sixels use private color registers. That is, the color palette from the last sixel is *not* re-used. When disabled, sixels share (i.e. re-use) the same color palette. Closes #362
2021-02-16 19:37:49 +01:00
case 1070: enable = term->xtsave.sixel_private_palette; break;
csi: implement XTRESTORE
2020-08-16 17:02:52 +02:00
case 2004: enable = term->xtsave.bracketed_paste; break;
csi: add support for DECSET 2026, as an alternative to BSU/ESU sequences See: https://gitlab.freedesktop.org/terminal-wg/specifications/-/merge_requests/2#note_847720
2021-04-25 18:35:46 +01:00
case 2026: enable = term->xtsave.app_sync_updates; break;
csi: implement DECSET/DECRST/DECRQM 2027 - grapheme cluster processing This implements private mode 2027 - grapheme cluster processing, as defined in the "Terminal Unicode Core"[1] specification. Internally, we just flip the already existing option "grapheme shaping". Since it's now runtime changeable, we need a copy of it in the terminal struct, rather than referencing the conf object. [1]: https://github.com/contour-terminal/terminal-unicode-core/blob/13fc5a8993a033ff10c1f3433d08cb618cde4ac2/spec/terminal-unicode-core.tex#L50-L53
2023-09-20 13:45:06 +02:00
case 2027: enable = term->xtsave.grapheme_shaping; break;
csi: implement private mode 2031 (dark/light mode detection) * Recognize 'CSI ? 996 n', and respond with - 'CSI ? 997 ; 1 n' if the primary theme is active - 'CSI ? 997 ; 2 n' if the alternative theme is actice * Implement private mode 2031, where changing the color theme (currently only possible via key bindings) causes the terminal to send the same CSI sequences as above. In this context, foot's primary theme is considered dark, and the alternative theme light (since the default theme is dark). Closes #2025
2025-04-20 12:48:37 +02:00
case 2031: enable = term->xtsave.report_theme_changes; break;
csi: in-band window resize notifications, private mode 2048 This implements https://gist.github.com/rockorager/e695fb2924d36b2bcf1fff4a3704bd83, in-band window resize notifications. When user enables private mode 2048 (in-band resize notifications), *always* send current size, even if the mode is already active. This ensures applications can rely on getting a reply from the terminal.
2024-06-30 19:44:17 +02:00
case 2048: enable = term->xtsave.size_notifications; break;
sixel: implement private mode 8452 - cursor positioning after sixel When disabled (the default), the cursor is positioned on a new line after emitting a sixel image. When enabled, the cursor is positioned to the right of the sixel image. Closes #363
2021-02-16 19:11:38 +01:00
case 8452: enable = term->xtsave.sixel_cursor_right_of_graphics; break;
csi: add DECSET 737769 - enables/disables IME input 73 77 69 = I M E
2020-12-04 21:26:38 +01:00
case 737769: enable = term->xtsave.ime; break;
csi: xtrestore: add 'default' case Don't call decset_decrst() with an unhandled parameter (and with 'enabled' uninitialized!)
2020-08-18 21:14:05 +02:00
default: return;
csi: implement XTRESTORE
2020-08-16 17:02:52 +02:00
}
decset_decrst(term, param, enable);
}
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
static bool
params_to_rectangular_area(const struct terminal *term, int first_idx,
int *top, int *left, int *bottom, int *right)
{
int rel_top = vt_param_get(term, first_idx + 0, 1) - 1;
csi: params_to_rectangular_area(): ensure left/right is within bounds
2024-03-10 17:37:11 +01:00
*left = min(vt_param_get(term, first_idx + 1, 1) - 1, term->cols - 1);
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
int rel_bottom = vt_param_get(term, first_idx + 2, term->rows) - 1;
csi: params_to_rectangular_area(): ensure left/right is within bounds
2024-03-10 17:37:11 +01:00
*right = min(vt_param_get(term, first_idx + 3, term->cols) - 1, term->cols - 1);
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
if (rel_top > rel_bottom || *left > *right)
return false;
*top = term_row_rel_to_abs(term, rel_top);
*bottom = term_row_rel_to_abs(term, rel_bottom);
csi: params_to_rectangular_area(): ensure left/right is within bounds
2024-03-10 17:37:11 +01:00
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
return true;
}
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
void
vt: improve logging of invalid and unimplemented sequences
2019-07-04 19:35:01 +02:00
csi_dispatch(struct terminal *term, uint8_t final)
{
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
LOG_DBG("%s (%08x)", csi_as_string(term, final, -1), term->vt.private);
csi: CSI log messages are now single line
2019-06-18 21:55:39 +02:00
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
switch (term->vt.private) {
terminal: only support a single intermediate/private character
2019-07-10 15:03:16 +02:00
case 0: {
wip: vt parsing
2019-06-17 18:57:12 +02:00
switch (final) {
csi: implement REP - CSI Ps b
2020-01-20 18:37:20 +01:00
case 'b':
if (term->vt.last_printed != 0) {
/*
* Note: we never reset 'last-printed'. According to
* ECMA-48, the behaviour is undefined if REP was
Fix some spelling mistakes
2020-08-15 19:39:00 +01:00
* _not_ preceded by a graphical character.
csi: implement REP - CSI Ps b
2020-01-20 18:37:20 +01:00
*/
int count = vt_param_get(term, 0, 1);
fix printf-format errors in 32-bit builds
2020-08-06 23:20:46 +02:00
LOG_DBG("REP: '%lc' %d times", (wint_t)term->vt.last_printed, count);
csi: implement REP - CSI Ps b
2020-01-20 18:37:20 +01:00
fcft: adapt to API changes in fcft-3.x Fcft no longer uses wchar_t, but plain uint32_t to represent codepoints. Since we do a fair amount of string operations in foot, it still makes sense to use something that actually _is_ a string (or character), rather than an array of uint32_t. For this reason, we switch out all wchar_t usage in foot to char32_t. We also verify, at compile-time, that char32_t used UTF-32 (which is what fcft expects). Unfortunately, there are no string functions for char32_t. To avoid having to re-implement all wcs*() functions, we add a small wrapper layer of c32*() functions. These wrapper functions take char32_t arguments, but then simply call the corresponding wcs*() function. For this to work, wcs*() must _also_ be UTF-32 compatible. We can check for the presence of the __STDC_ISO_10646__ macro. If set, wchar_t is at least 4 bytes and its internal representation is UTF-32. FreeBSD does *not* define this macro, because its internal wchar_t representation depends on the current locale. It _does_ use UTF-32 _if_ the current locale is UTF-8. Since foot enforces UTF-8, we simply need to check if __FreeBSD__ is defined. Other fcft API changes: * fcft_glyph_rasterize() -> fcft_codepoint_rasterize() * font.space_advance has been removed * ‘tags’ have been removed from fcft_grapheme_rasterize() * ‘fcft_log_init()’ removed * ‘fcft_init()’ and ‘fcft_fini()’ must be explicitly called
2021-08-21 14:50:42 +02:00
const int width = c32width(term->vt.last_printed);
csi: never call term_print() with width <= 0
2020-07-16 08:06:37 +02:00
if (width > 0) {
for (int i = 0; i < count; i++)
term: insert-mode: handle combining characters correctly When the client application emits combining characters, for example multi-codepoint emojis, in insert-mode, we ended up pushing partial graphemes to the right, for each codepoint, resulting in too many cells (and with the wrong content) being inserted. The fix is fairly simple; don't "insert" when appending characters to an existing grapheme cluster. This isn't something we can detect easily in print_insert() (it would require us to do grapheme clustering again). Fortunately, we do have the required information in action_utf8_print(). So, pass this information as a boolean to term_print(). Closes #1947
2025-02-06 07:31:30 +01:00
term_print(term, term->vt.last_printed, width, false);
csi: never call term_print() with width <= 0
2020-07-16 08:06:37 +02:00
}
csi: implement REP - CSI Ps b
2020-01-20 18:37:20 +01:00
}
break;
csi: improve "Send Device Attributes (Primary DA)" Pretend we're a VT420, with a couple of supported features indicated. Note that I haven't verified we support *everything* that each features entails - or even what exactly a feature *is* (locator port?)
2019-11-18 12:07:17 +01:00
case 'c': {
csi: only respond to Primary DA when Ps == 0
2020-10-09 18:53:00 +02:00
if (vt_param_get(term, 0, 0) != 0) {
UNHANDLED();
break;
}
csi: improve "Send Device Attributes (Primary DA)" Pretend we're a VT420, with a couple of supported features indicated. Note that I haven't verified we support *everything* that each features entails - or even what exactly a feature *is* (locator port?)
2019-11-18 12:07:17 +01:00
/* Send Device Attributes (Primary DA) */
/*
* Responses:
* - CSI?1;2c vt100 with advanced video option
* - CSI?1;0c vt101 with no options
* - CSI?6c vt102
* - CSI?62;<Ps>c vt220
* - CSI?63;<Ps>c vt320
* - CSI?64;<Ps>c vt420
*
* Ps (response may contain multiple):
* - 1 132 columns
* - 2 Printer.
* - 3 ReGIS graphics.
* - 4 Sixel graphics.
* - 6 Selective erase.
* - 8 User-defined keys.
* - 9 National Replacement Character sets.
* - 15 Technical characters.
* - 16 Locator port.
* - 17 Terminal state interrogation.
* - 18 User windows.
* - 21 Horizontal scrolling.
* - 22 ANSI color, e.g., VT525.
* - 28 Rectangular editing.
* - 29 ANSI text locator (i.e., DEC Locator mode).
csi: primary DA: remove features we do not support We do not implement * Selective Erase * Technical Character Set * Terminal state interrogation
2020-07-24 17:46:18 +02:00
*
* Note: we report ourselves as a VT220, mainly to be able
Fix some spelling mistakes
2020-08-15 19:39:00 +01:00
* to pass parameters, to indicate we support sixel, and
csi: primary DA: remove features we do not support We do not implement * Selective Erase * Technical Character Set * Terminal state interrogation
2020-07-24 17:46:18 +02:00
* ANSI colors.
*
* The VT level must be synchronized with the secondary DA
* response.
*
* Note: tertiary DA responds with "FOOT".
csi: improve "Send Device Attributes (Primary DA)" Pretend we're a VT420, with a couple of supported features indicated. Note that I haven't verified we support *everything* that each features entails - or even what exactly a feature *is* (locator port?)
2019-11-18 12:07:17 +01:00
*/
config: add tweak option to allow disabling sixels Closes #950
2022-02-27 16:29:35 +01:00
if (term->conf->tweak.sixel) {
csi: add ‘28’ (rectangular edit) to primary DA response
2021-12-26 15:03:55 +01:00
static const char reply[] = "\033[?62;4;22;28c";
config: add tweak option to allow disabling sixels Closes #950
2022-02-27 16:29:35 +01:00
term_to_slave(term, reply, sizeof(reply) - 1);
} else {
csi: add ‘28’ (rectangular edit) to primary DA response
2021-12-26 15:03:55 +01:00
static const char reply[] = "\033[?62;22;28c";
config: add tweak option to allow disabling sixels Closes #950
2022-02-27 16:29:35 +01:00
term_to_slave(term, reply, sizeof(reply) - 1);
}
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
break;
csi: improve "Send Device Attributes (Primary DA)" Pretend we're a VT420, with a couple of supported features indicated. Note that I haven't verified we support *everything* that each features entails - or even what exactly a feature *is* (locator port?)
2019-11-18 12:07:17 +01:00
}
wip: vt parsing
2019-06-17 18:57:12 +02:00
csi: implement VPA (vertical line position absolute)
2019-06-24 19:59:54 +02:00
case 'd': {
csi: VPA: saturate row
2019-06-24 20:05:24 +02:00
/* VPA - vertical line position absolute */
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 rel_row = vt_param_get(term, 0, 1) - 1;
int row = term_row_rel_to_abs(term, rel_row);
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
term_cursor_to(term, row, term->grid->cursor.point.col);
csi: implement VPA (vertical line position absolute)
2019-06-24 19:59:54 +02:00
break;
}
wip: vt parsing
2019-06-17 18:57:12 +02:00
case 'm':
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
csi_sgr(term);
break;
wip: vt parsing
2019-06-17 18:57:12 +02:00
csi: add function param_get() Returns the value of parameter #idx, if available, or the specified default value. If the specified parameter does exist, but is 0, the default value is returned.
2019-06-24 20:17:02 +02:00
case 'A':
vt/csi: use vt_param_get()
2019-07-10 16:04:16 +02:00
term_cursor_up(term, vt_param_get(term, 0, 1));
csi: implement CSI Pn P (DCH - delete character)
2019-06-22 21:31:28 +02:00
break;
csi: implement VPR (vertical line position relative)
2019-06-24 20:05:31 +02:00
case 'e':
csi: add function param_get() Returns the value of parameter #idx, if available, or the specified default value. If the specified parameter does exist, but is 0, the default value is returned.
2019-06-24 20:17:02 +02:00
case 'B':
vt/csi: use vt_param_get()
2019-07-10 16:04:16 +02:00
term_cursor_down(term, vt_param_get(term, 0, 1));
csi: implement CSI Pn P (DCH - delete character)
2019-06-22 21:31:28 +02:00
break;
csi: implement 'HPR' - Horizontal Position Relative
2019-11-17 11:31:35 +01:00
case 'a':
csi: add function param_get() Returns the value of parameter #idx, if available, or the specified default value. If the specified parameter does exist, but is 0, the default value is returned.
2019-06-24 20:17:02 +02:00
case 'C':
vt/csi: use vt_param_get()
2019-07-10 16:04:16 +02:00
term_cursor_right(term, vt_param_get(term, 0, 1));
csi: implement CSI Pn P (DCH - delete character)
2019-06-22 21:31:28 +02:00
break;
csi: add function param_get() Returns the value of parameter #idx, if available, or the specified default value. If the specified parameter does exist, but is 0, the default value is returned.
2019-06-24 20:17:02 +02:00
case 'D':
vt/csi: use vt_param_get()
2019-07-10 16:04:16 +02:00
term_cursor_left(term, vt_param_get(term, 0, 1));
csi: implement CSI Pn P (DCH - delete character)
2019-06-22 21:31:28 +02:00
break;
csi: implement 'CNL' - Cursor Next Line
2019-11-17 11:34:53 +01:00
case 'E':
/* CNL - Cursor Next Line */
term_cursor_down(term, vt_param_get(term, 0, 1));
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
term_cursor_left(term, term->grid->cursor.point.col);
csi: implement 'CNL' - Cursor Next Line
2019-11-17 11:34:53 +01:00
break;
csi: implement 'CPL' - Cursor Previous Line
2019-11-17 11:36:24 +01:00
case 'F':
/* CPL - Cursor Previous Line */
term_cursor_up(term, vt_param_get(term, 0, 1));
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
term_cursor_left(term, term->grid->cursor.point.col);
csi: implement 'CPL' - Cursor Previous Line
2019-11-17 11:36:24 +01:00
break;
csi: implement CSI 0g and CSI 3g * 0g - clear tab stop at current column * 3g - clear all tab stops
2019-11-16 10:55:28 +01:00
case 'g': {
int param = vt_param_get(term, 0, 0);
switch (param) {
case 0:
/* Clear tab stop at *current* column */
tll_foreach(term->tab_stops, it) {
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
if (it->item == term->grid->cursor.point.col)
csi: implement CSI 0g and CSI 3g * 0g - clear tab stop at current column * 3g - clear all tab stops
2019-11-16 10:55:28 +01:00
tll_remove(term->tab_stops, it);
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
else if (it->item > term->grid->cursor.point.col)
csi: implement CSI 0g and CSI 3g * 0g - clear tab stop at current column * 3g - clear all tab stops
2019-11-16 10:55:28 +01:00
break;
}
break;
case 3:
/* Clear *all* tabs */
tll_free(term->tab_stops);
break;
default:
UNHANDLED();
break;
}
break;
}
csi: implement 'HPA' - Horizontal Position Absolute
2019-11-17 11:09:16 +01:00
case '`':
csi: implement cursor horizontal absolute
2019-06-24 20:08:44 +02:00
case 'G': {
/* Cursor horizontal absolute */
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 col = min(vt_param_get(term, 0, 1), term->cols) - 1;
csi: CHA+HPA (cursor horizontal absolute): use term_cursor_col()
2023-06-16 16:34:17 +02:00
term_cursor_col(term, col);
csi: implement cursor horizontal absolute
2019-06-24 20:08:44 +02:00
break;
}
csi: implement force cursor position
2019-11-05 11:10:19 +01:00
case 'f':
csi: implement 'CSI H' (set cursor position)
2019-06-23 14:11:35 +02:00
case 'H': {
/* Move cursor */
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 rel_row = vt_param_get(term, 0, 1) - 1;
int row = term_row_rel_to_abs(term, rel_row);
int col = min(vt_param_get(term, 1, 1), term->cols) - 1;
term_cursor_to(term, row, col);
csi: implement 'CSI H' (set cursor position)
2019-06-23 14:11:35 +02:00
break;
}
wip: vt parsing
2019-06-17 18:57:12 +02:00
case 'J': {
wip: initial input handling
2019-06-19 10:04:47 +02:00
/* Erase screen */
vt/csi: use vt_param_get()
2019-07-10 16:04:16 +02:00
int param = vt_param_get(term, 0, 0);
wip: initial input handling
2019-06-19 10:04:47 +02:00
switch (param) {
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
case 0: {
wip: initial input handling
2019-06-19 10:04:47 +02:00
/* From cursor to end of screen */
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
const struct coord *cursor = &term->grid->cursor.point;
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
term_erase(
term,
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
cursor->row, cursor->col,
term->rows - 1, term->cols - 1);
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
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
}
wip: initial input handling
2019-06-19 10:04:47 +02:00
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
case 1: {
wip: initial input handling
2019-06-19 10:04:47 +02:00
/* From start of screen to cursor */
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
const struct coord *cursor = &term->grid->cursor.point;
term_erase(term, 0, 0, cursor->row, cursor->col);
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
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
}
wip: initial input handling
2019-06-19 10:04:47 +02:00
case 2:
/* Erase entire screen */
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
term_erase(term, 0, 0, term->rows - 1, term->cols - 1);
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
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
csi: implement CSI 3J - erase scroll back
2019-07-22 19:05:22 +02:00
case 3: {
/* Erase scrollback */
csi: erase scrollback: cancel selection if it touches the scrollback This breaks out the scrollback erasing logic for \E[3J from csi.c, and moves it to the new function term_erase_scrollback(), and changes the logic to calculate the start and end row (absolute) numbers of the scrollback, and only iterate those, instead of iterating *all* rows, filtering out those that are on-screen. It also adds an intersection range check of the selection range, and cancels the selection if it touches any of the deleted scrollback rows. This fixes a crash when trying to render the next frame, since the selection now references rows that have been freed. Closes #633
2021-07-16 16:45:36 +02:00
term_erase_scrollback(term);
csi: implement CSI 3J - erase scroll back
2019-07-22 19:05:22 +02:00
break;
}
wip: initial input handling
2019-06-19 10:04:47 +02:00
default:
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
UNHANDLED();
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
break;
wip: initial input handling
2019-06-19 10:04:47 +02:00
}
break;
wip: vt parsing
2019-06-17 18:57:12 +02:00
}
case 'K': {
wip: initial input handling
2019-06-19 10:04:47 +02:00
/* Erase line */
vt/csi: use vt_param_get()
2019-07-10 16:04:16 +02:00
int param = vt_param_get(term, 0, 0);
wip: initial input handling
2019-06-19 10:04:47 +02:00
switch (param) {
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
case 0: {
wip: initial input handling
2019-06-19 10:04:47 +02:00
/* From cursor to end of line */
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
const struct coord *cursor = &term->grid->cursor.point;
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
term_erase(
term,
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
cursor->row, cursor->col,
cursor->row, term->cols - 1);
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
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
}
wip: initial input handling
2019-06-19 10:04:47 +02:00
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
case 1: {
wip: initial input handling
2019-06-19 10:04:47 +02:00
/* From start of line to cursor */
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
const struct coord *cursor = &term->grid->cursor.point;
term_erase(term, cursor->row, 0, cursor->row, cursor->col);
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
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
}
wip: initial input handling
2019-06-19 10:04:47 +02:00
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
case 2: {
wip: initial input handling
2019-06-19 10:04:47 +02:00
/* Entire line */
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
const struct coord *cursor = &term->grid->cursor.point;
term_erase(term, cursor->row, 0, cursor->row, term->cols - 1);
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
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
}
wip: initial input handling
2019-06-19 10:04:47 +02:00
default:
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
UNHANDLED();
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
break;
wip: initial input handling
2019-06-19 10:04:47 +02:00
}
wip: vt parsing
2019-06-17 18:57:12 +02:00
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
}
selection: selection_on_rows(): typo: row_start -> row_end This fixes an issue where selections in the scroll margins were not detected correctly. This meant they weren’t canceled as they should have been, which in turn caused a visual glitch where text appeared to be selected, but were in fact not.
2022-11-24 17:05:27 +01:00
case 'L': { /* IL */
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
if (term->grid->cursor.point.row < term->scroll_region.start ||
term->grid->cursor.point.row >= term->scroll_region.end)
scrolling region: wip
2019-06-23 21:12:32 +02:00
break;
int count = min(
vt/csi: use vt_param_get()
2019-07-10 16:04:16 +02:00
vt_param_get(term, 0, 1),
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
term->scroll_region.end - term->grid->cursor.point.row);
scrolling region: wip
2019-06-23 21:12:32 +02:00
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
term_scroll_reverse_partial(
term,
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){
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
.start = term->grid->cursor.point.row,
terminal: move col/row count, cell width/height and scroll region to terminal
2019-06-29 21:08:08 +02:00
.end = term->scroll_region.end},
scrolling region: wip
2019-06-23 21:12:32 +02:00
count);
csi: IND+RI now clears LCF
2020-07-14 10:52:15 +02:00
term->grid->cursor.lcf = false;
csi: IL+DL: move cursor to column 0 This fixes vttest 11.6.6.3 Test non-VT100 -> Test ISO-6429 colors -> Test of VT102-style features with BCE -> Test Insert/Delete Char/Line
2021-06-07 21:57:11 +02:00
term->grid->cursor.point.col = 0;
scrolling region: wip
2019-06-23 21:12:32 +02:00
break;
}
selection: selection_on_rows(): typo: row_start -> row_end This fixes an issue where selections in the scroll margins were not detected correctly. This meant they weren’t canceled as they should have been, which in turn caused a visual glitch where text appeared to be selected, but were in fact not.
2022-11-24 17:05:27 +01:00
case 'M': { /* DL */
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
if (term->grid->cursor.point.row < term->scroll_region.start ||
term->grid->cursor.point.row >= term->scroll_region.end)
scrolling region: wip
2019-06-23 21:12:32 +02:00
break;
int count = min(
vt/csi: use vt_param_get()
2019-07-10 16:04:16 +02:00
vt_param_get(term, 0, 1),
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
term->scroll_region.end - term->grid->cursor.point.row);
scrolling region: wip
2019-06-23 21:12:32 +02:00
Rename grid_* functions to term_*
2019-06-29 21:03:28 +02:00
term_scroll_partial(
term,
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){
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
.start = term->grid->cursor.point.row,
terminal: move col/row count, cell width/height and scroll region to terminal
2019-06-29 21:08:08 +02:00
.end = term->scroll_region.end},
scrolling region: wip
2019-06-23 21:12:32 +02:00
count);
csi: IND+RI now clears LCF
2020-07-14 10:52:15 +02:00
term->grid->cursor.lcf = false;
csi: IL+DL: move cursor to column 0 This fixes vttest 11.6.6.3 Test non-VT100 -> Test ISO-6429 colors -> Test of VT102-style features with BCE -> Test Insert/Delete Char/Line
2021-06-07 21:57:11 +02:00
term->grid->cursor.point.col = 0;
scrolling region: wip
2019-06-23 21:12:32 +02:00
break;
}
csi: implement CSI Pn P (DCH - delete character)
2019-06-22 21:31:28 +02:00
case 'P': {
csi: implement \E[@ (ICH - insert characters)
2019-07-17 11:19:28 +02:00
/* DCH: Delete character(s) */
wip: initial input handling
2019-06-19 10:04:47 +02:00
csi: repair DCH (delete character) The logic was simply broken. This fixes it, and also converts it to use the new "current line" pointer.
2019-07-02 22:19:43 +02:00
/* Number of characters to delete */
int count = min(
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
vt_param_get(term, 0, 1), term->cols - term->grid->cursor.point.col);
wip: vt parsing
2019-06-17 18:57:12 +02:00
csi: repair DCH (delete character) The logic was simply broken. This fixes it, and also converts it to use the new "current line" pointer.
2019-07-02 22:19:43 +02:00
/* Number of characters left after deletion (on current line) */
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
int remaining = term->cols - (term->grid->cursor.point.col + count);
csi: implement CSI Pn P (DCH - delete character)
2019-06-22 21:31:28 +02:00
csi: repair DCH (delete character) The logic was simply broken. This fixes it, and also converts it to use the new "current line" pointer.
2019-07-02 22:19:43 +02:00
/* 'Delete' characters by moving the remaining ones */
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
memmove(&term->grid->cur_row->cells[term->grid->cursor.point.col],
&term->grid->cur_row->cells[term->grid->cursor.point.col + count],
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
remaining * sizeof(term->grid->cur_row->cells[0]));
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
for (size_t c = 0; c < remaining; c++)
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
term->grid->cur_row->cells[term->grid->cursor.point.col + c].attrs.clean = 0;
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
term->grid->cur_row->dirty = true;
csi: repair DCH (delete character) The logic was simply broken. This fixes it, and also converts it to use the new "current line" pointer.
2019-07-02 22:19:43 +02:00
/* Erase the remainder of the line */
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
const struct coord *cursor = &term->grid->cursor.point;
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
term_erase(
term,
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
cursor->row, cursor->col + remaining,
cursor->row, term->cols - 1);
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
term->grid->cursor.lcf = false;
csi: implement \E[@ (ICH - insert characters)
2019-07-17 11:19:28 +02:00
break;
}
case '@': {
/* ICH: insert character(s) */
/* Number of characters to insert */
int count = min(
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
vt_param_get(term, 0, 1), term->cols - term->grid->cursor.point.col);
csi: implement \E[@ (ICH - insert characters)
2019-07-17 11:19:28 +02:00
/* Characters to move */
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
int remaining = term->cols - (term->grid->cursor.point.col + count);
csi: implement \E[@ (ICH - insert characters)
2019-07-17 11:19:28 +02:00
/* Push existing characters */
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
memmove(&term->grid->cur_row->cells[term->grid->cursor.point.col + count],
&term->grid->cur_row->cells[term->grid->cursor.point.col],
csi: implement \E[@ (ICH - insert characters)
2019-07-17 11:19:28 +02:00
remaining * sizeof(term->grid->cur_row->cells[0]));
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
for (size_t c = 0; c < remaining; c++)
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
term->grid->cur_row->cells[term->grid->cursor.point.col + count + c].attrs.clean = 0;
csi: implement \E[@ (ICH - insert characters)
2019-07-17 11:19:28 +02:00
term->grid->cur_row->dirty = true;
/* Erase (insert space characters) */
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
const struct coord *cursor = &term->grid->cursor.point;
csi: repair DCH (delete character) The logic was simply broken. This fixes it, and also converts it to use the new "current line" pointer.
2019-07-02 22:19:43 +02:00
term_erase(
csi: implement \E[@ (ICH - insert characters)
2019-07-17 11:19:28 +02:00
term,
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
cursor->row, cursor->col,
cursor->row, cursor->col + count - 1);
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
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
csi: add untested implementation of "horizontal index"
2019-07-03 14:47:01 +02:00
}
term: scrolling: calling function must clamp scroll amount
2020-05-19 18:47:38 +02:00
case 'S': {
csi: various, minor code/formatting improvements
2021-08-30 07:40:03 +01:00
const struct scroll_region *r = &term->scroll_region;
int amount = min(vt_param_get(term, 0, 1), r->end - r->start);
term: scrolling: calling function must clamp scroll amount
2020-05-19 18:47:38 +02:00
term_scroll(term, amount);
csi: implement CSI S and CSI T (scroll up/down)
2019-07-04 19:39:23 +02:00
break;
term: scrolling: calling function must clamp scroll amount
2020-05-19 18:47:38 +02:00
}
csi: implement CSI S and CSI T (scroll up/down)
2019-07-04 19:39:23 +02:00
term: scrolling: calling function must clamp scroll amount
2020-05-19 18:47:38 +02:00
case 'T': {
csi: various, minor code/formatting improvements
2021-08-30 07:40:03 +01:00
const struct scroll_region *r = &term->scroll_region;
int amount = min(vt_param_get(term, 0, 1), r->end - r->start);
term: scrolling: calling function must clamp scroll amount
2020-05-19 18:47:38 +02:00
term_scroll_reverse(term, amount);
csi: implement CSI S and CSI T (scroll up/down)
2019-07-04 19:39:23 +02:00
break;
term: scrolling: calling function must clamp scroll amount
2020-05-19 18:47:38 +02:00
}
csi: implement CSI S and CSI T (scroll up/down)
2019-07-04 19:39:23 +02:00
csi: implement 'erase characters' (CSI X)
2019-07-03 15:58:49 +02:00
case 'X': {
/* Erase chars */
int count = min(
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
vt_param_get(term, 0, 1), term->cols - term->grid->cursor.point.col);
csi: implement 'erase characters' (CSI X)
2019-07-03 15:58:49 +02:00
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
const struct coord *cursor = &term->grid->cursor.point;
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
term_erase(
term,
term_erase(): replace coord-typed arguments with regular ints
2021-12-25 19:12:51 +01:00
cursor->row, cursor->col,
cursor->row, cursor->col + count - 1);
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
term->grid->cursor.lcf = false;
csi: implement 'erase characters' (CSI X)
2019-07-03 15:58:49 +02:00
break;
}
csi: implement 'CHT' - Cursor Horizontal Tab
2019-11-17 12:29:52 +01:00
case 'I': {
/* CHT - Tab Forward (param is number of tab stops to move through) */
for (int i = 0; i < vt_param_get(term, 0, 1); i++) {
int new_col = term->cols - 1;
tll_foreach(term->tab_stops, it) {
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
if (it->item > term->grid->cursor.point.col) {
csi: implement 'CHT' - Cursor Horizontal Tab
2019-11-17 12:29:52 +01:00
new_col = it->item;
break;
}
}
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(new_col >= term->grid->cursor.point.col);
csi: CHT: don’t alter the LCF flag This makes us pass the vttest 11.5.4 (Test non-VT100 -> Test ISO-6429 cursor-movement -> CHT) test.
2021-06-07 21:18:15 +02:00
bool lcf = term->grid->cursor.lcf;
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
term_cursor_right(term, new_col - term->grid->cursor.point.col);
csi: CHT: don’t alter the LCF flag This makes us pass the vttest 11.5.4 (Test non-VT100 -> Test ISO-6429 cursor-movement -> CHT) test.
2021-06-07 21:18:15 +02:00
term->grid->cursor.lcf = lcf;
csi: implement 'CHT' - Cursor Horizontal Tab
2019-11-17 12:29:52 +01:00
}
break;
}
csi: fix bad implementation of CBT (back tab) * It takes a parameter, that indicates the number of tab stops to move through * Use the tab stops defined in the tab stops list, not hard coded mod 8 columns.
2019-11-17 11:20:59 +01:00
case 'Z':
/* CBT - Back tab (param is number of tab stops to move back through) */
for (int i = 0; i < vt_param_get(term, 0, 1); i++) {
int new_col = 0;
tll_rforeach(term->tab_stops, it) {
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
if (it->item < term->grid->cursor.point.col) {
csi: fix bad implementation of CBT (back tab) * It takes a parameter, that indicates the number of tab stops to move through * Use the tab stops defined in the tab stops list, not hard coded mod 8 columns.
2019-11-17 11:20:59 +01:00
new_col = it->item;
break;
}
}
debug: rename assert() to xassert(), to avoid clashing with <assert.h>
2021-01-16 20:16:00 +00:00
xassert(term->grid->cursor.point.col >= new_col);
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
term_cursor_left(term, term->grid->cursor.point.col - new_col);
csi: fix bad implementation of CBT (back tab) * It takes a parameter, that indicates the number of tab stops to move through * Use the tab stops defined in the tab stops list, not hard coded mod 8 columns.
2019-11-17 11:20:59 +01:00
}
csi: implement \E[Z - back tab
2019-07-22 20:33:50 +02:00
break;
vt: implement (untested!) insert mode \E4l is not horizontal index, but disable INSERT mode
2019-07-03 21:16:41 +02:00
case 'h':
csi: simplify handling of Set/Reset Mode (SM/RM) sequences
2024-01-25 01:07:53 +00:00
case 'l': {
/* Set/Reset Mode (SM/RM) */
int param = vt_param_get(term, 0, 0);
bool sm = final == 'h';
if (param == 4) {
/* Insertion Replacement Mode (IRM) */
term->insert_mode = sm;
term: performance: use a bitfield to track which ascii printer to use The things affecting which ASCII printer we use have grown... Instead of checking everything inside term_update_ascii_printer(), use a bitfield. Anything affecting the printer used, must now set a bit in this bitfield. This makes term_update_ascii_printer() much faster, since all it needs to do is check if the bitfield is zero or not.
2024-06-24 01:26:57 +02:00
term->bits_affecting_ascii_printer.insert_mode = sm;
term: runtime switch between a ‘fast’ and a ‘generic’ ASCII print function term_print() is called whenever the client application “prints” something to the grid. It is called for both ASCII and UTF-8 characters, and needs to handle sixels, insert mode and ASCII vs. graphical charsets. Since it’s on the hot path, this becomes unnecessarily slow. This patch adds a “fast” version of term_print(), tailored for the common case: ASCII characters in non-insert mode, without any sixels and non-graphical charsets. A new function, term_update_ascii_printer(), has been added, and must be called whenever: * The currently selected charset *index* changes * The currently selected charset changes (from ASCII to graphical, or vice verse) * Sixels are added to the grid * Sixels are removed from the grid * Insert mode is enabled/disabled
2021-03-14 19:19:10 +01:00
term_update_ascii_printer(term);
csi: CSI h isn't a valid sequence - it needs a parameter And, 'insert mode' isn't activated with \e[h, but with \e[4h.
2019-08-30 22:01:05 +02:00
break;
}
csi: add untested implementation of "horizontal index"
2019-07-03 14:47:01 +02:00
csi: simplify handling of Set/Reset Mode (SM/RM) sequences
2024-01-25 01:07:53 +00:00
/*
* ECMA-48 defines modes 1-22, all of which were optional
* (§7.1; "may have one state only") and are considered
* deprecated (§7.1) in the latest (5th) edition. xterm only
* documents modes 2, 4, 12 and 20, the last of which was
* outright removed (§8.3.106) in 5th edition ECMA-48.
*/
if (sm) {
LOG_WARN("SM with unimplemented mode: %d", param);
csi: CSI h isn't a valid sequence - it needs a parameter And, 'insert mode' isn't activated with \e[h, but with \e[4h.
2019-08-30 22:01:05 +02:00
}
csi: add untested implementation of "horizontal index"
2019-07-03 14:47:01 +02:00
break;
csi: simplify handling of Set/Reset Mode (SM/RM) sequences
2024-01-25 01:07:53 +00:00
}
wip: vt parsing
2019-06-17 18:57:12 +02:00
vt: wip: implement scrolling region This is largely untested, but existing scrolling code has been converted to using a terminal-global scrolling region that is defined as start-end of the scrollable region. This is compared to the old code where the scrolling region where defined in terms of marginals, counted in lines from top and from bottom.
2019-06-23 18:02:49 +02:00
case 'r': {
vt/csi: use vt_param_get()
2019-07-10 16:04:16 +02:00
int start = vt_param_get(term, 0, 1);
int end = min(vt_param_get(term, 1, term->rows), term->rows);
scrolling region: wip
2019-06-23 21:12:32 +02:00
csi: ignore invalid scrolling regions There must be at least one scrolling row. I.e. the bottom margin must be larger than the top margin. Note that trying to set an invalid region really will be *ignored*. I.e. we *don't* reset the scrolling region. This conforms to xterm's behavior.
2019-09-29 14:58:02 +02:00
if (end > start) {
scrolling region: wip
2019-06-23 21:12:32 +02:00
csi: ignore invalid scrolling regions There must be at least one scrolling row. I.e. the bottom margin must be larger than the top margin. Note that trying to set an invalid region really will be *ignored*. I.e. we *don't* reset the scrolling region. This conforms to xterm's behavior.
2019-09-29 14:58:02 +02:00
/* 1-based */
term->scroll_region.start = start - 1;
term->scroll_region.end = end;
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
term_cursor_home(term);
csi: ignore invalid scrolling regions There must be at least one scrolling row. I.e. the bottom margin must be larger than the top margin. Note that trying to set an invalid region really will be *ignored*. I.e. we *don't* reset the scrolling region. This conforms to xterm's behavior.
2019-09-29 14:58:02 +02:00
LOG_DBG("scroll region: %d-%d",
term->scroll_region.start,
term->scroll_region.end);
}
vt: wip: implement scrolling region This is largely untested, but existing scrolling code has been converted to using a terminal-global scrolling region that is defined as start-end of the scrollable region. This is compared to the old code where the scrolling region where defined in terms of marginals, counted in lines from top and from bottom.
2019-06-23 18:02:49 +02:00
break;
}
term: make sure to update 'current row' when restoring saved cursor
2019-07-23 17:57:07 +02:00
case 's':
term/vt/csi: break out cursor save/restore to dedicated functions
2021-01-15 17:08:30 +01:00
term_save_cursor(term);
term: make sure to update 'current row' when restoring saved cursor
2019-07-23 17:57:07 +02:00
break;
case 'u':
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
term_restore_cursor(term, &term->grid->saved_cursor);
term: make sure to update 'current row' when restoring saved cursor
2019-07-23 17:57:07 +02:00
break;
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
case 't': {
csi: implement window and cell size reporting escapes This implements the following queries: * report window size in pixels * report cell size in pixels * report window size in chars We also log a warning for the remaining window operation queries.
2020-02-01 19:27:52 +01:00
/*
* Window operations
*/
const unsigned param = vt_param_get(term, 0, 0);
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
switch (param) {
csi: implement window and cell size reporting escapes This implements the following queries: * report window size in pixels * report cell size in pixels * report window size in chars We also log a warning for the remaining window operation queries.
2020-02-01 19:27:52 +01:00
case 1: LOG_WARN("unimplemented: de-iconify"); break;
case 2: LOG_WARN("unimplemented: iconify"); break;
case 3: LOG_WARN("unimplemented: move window to pixel position"); break;
case 4: LOG_WARN("unimplemented: resize window in pixels"); break;
case 5: LOG_WARN("unimplemented: raise window to front of stack"); break;
case 6: LOG_WARN("unimplemented: raise window to back of stack"); break;
case 7: LOG_WARN("unimplemented: refresh window"); break;
case 8: LOG_WARN("unimplemented: resize window in chars"); break;
case 9: LOG_WARN("unimplemented: maximize/unmaximize window"); break;
case 10: LOG_WARN("unimplemented: to/from full screen"); break;
csi: revert implementation of CSI 20 t
2024-09-13 08:57:07 +02:00
case 20: LOG_WARN("unimplemented: report icon label"); break;
csi: implement window and cell size reporting escapes This implements the following queries: * report window size in pixels * report cell size in pixels * report window size in chars We also log a warning for the remaining window operation queries.
2020-02-01 19:27:52 +01:00
case 24: LOG_WARN("unimplemented: resize window (DECSLPP)"); break;
csi: implement CSI Ps ; Ps ; Ps t reporting escape sequences A lot of the escape sequences on the "CSI Ps ; Ps ; Ps t" form are expected to return a reply. Thus, not having these implemented means we will hang if the client sends these escapes. Not all of these escapes can be meaningfully implemented on Wayland, and thus this implementation is best effort. We now support the following escapes: * 11t - report if window is iconified (always replies "no") * 13t - report window position (always replies 0,0) * 13;2t - report text area position (replies with margins, since we cannot get the window's position) * 14t - report text area size, in pixels * 14;2t - report window size, in pixels * 15t - report screen size, in pixels * 16t - report cell size, in pixels * 18t - report text area size, in cells * 19t - report screen size, in cells
2020-04-17 23:03:20 +02:00
case 11: /* report if window is iconified */
/* We don't know - always report *not* iconified */
/* 1=not iconified, 2=iconified */
term_to_slave(term, "\033[1t", 4);
break;
case 13: { /* report window position */
csi: ‘CSI 13 ; 2 t’ reply is now (0,0) Foot previously responded with window local coordinates. But, XTerm responds with screen *absolute* coordinates. This isn’t possible under Wayland, thus we now report (0,0) instead. Same as we do for ‘CSI 13 ; 0 t’.
2021-02-16 14:31:46 +01:00
/* We don't know our position - always report (0,0) */
csi: various, minor code/formatting improvements
2021-08-30 07:40:03 +01:00
static const char reply[] = "\033[3;0;0t";
csi: implement CSI Ps ; Ps ; Ps t reporting escape sequences A lot of the escape sequences on the "CSI Ps ; Ps ; Ps t" form are expected to return a reply. Thus, not having these implemented means we will hang if the client sends these escapes. Not all of these escapes can be meaningfully implemented on Wayland, and thus this implementation is best effort. We now support the following escapes: * 11t - report if window is iconified (always replies "no") * 13t - report window position (always replies 0,0) * 13;2t - report text area position (replies with margins, since we cannot get the window's position) * 14t - report text area size, in pixels * 14;2t - report window size, in pixels * 15t - report screen size, in pixels * 16t - report cell size, in pixels * 18t - report text area size, in cells * 19t - report screen size, in cells
2020-04-17 23:03:20 +02:00
switch (vt_param_get(term, 1, 0)) {
csi: various, minor code/formatting improvements
2021-08-30 07:40:03 +01:00
case 0: /* window position */
case 2: /* text area position */
term_to_slave(term, reply, sizeof(reply) - 1);
csi: implement CSI Ps ; Ps ; Ps t reporting escape sequences A lot of the escape sequences on the "CSI Ps ; Ps ; Ps t" form are expected to return a reply. Thus, not having these implemented means we will hang if the client sends these escapes. Not all of these escapes can be meaningfully implemented on Wayland, and thus this implementation is best effort. We now support the following escapes: * 11t - report if window is iconified (always replies "no") * 13t - report window position (always replies 0,0) * 13;2t - report text area position (replies with margins, since we cannot get the window's position) * 14t - report text area size, in pixels * 14;2t - report window size, in pixels * 15t - report screen size, in pixels * 16t - report cell size, in pixels * 18t - report text area size, in cells * 19t - report screen size, in cells
2020-04-17 23:03:20 +02:00
break;
default:
UNHANDLED();
break;
}
break;
}
csi: implement window and cell size reporting escapes This implements the following queries: * report window size in pixels * report cell size in pixels * report window size in chars We also log a warning for the remaining window operation queries.
2020-02-01 19:27:52 +01:00
case 14: { /* report window size in pixels */
csi: implement CSI Ps ; Ps ; Ps t reporting escape sequences A lot of the escape sequences on the "CSI Ps ; Ps ; Ps t" form are expected to return a reply. Thus, not having these implemented means we will hang if the client sends these escapes. Not all of these escapes can be meaningfully implemented on Wayland, and thus this implementation is best effort. We now support the following escapes: * 11t - report if window is iconified (always replies "no") * 13t - report window position (always replies 0,0) * 13;2t - report text area position (replies with margins, since we cannot get the window's position) * 14t - report text area size, in pixels * 14;2t - report window size, in pixels * 15t - report screen size, in pixels * 16t - report cell size, in pixels * 18t - report text area size, in cells * 19t - report screen size, in cells
2020-04-17 23:03:20 +02:00
int width = -1;
int height = -1;
switch (vt_param_get(term, 1, 0)) {
case 0:
/* text area size */
width = term->width - term->margins.left - term->margins.right;
height = term->height - term->margins.top - term->margins.bottom;
break;
case 2:
/* window size */
width = term->width;
height = term->height;
break;
default:
UNHANDLED();
break;
}
if (width >= 0 && height >= 0) {
char reply[64];
term: convert ‘scale’ to a float
2023-06-22 14:21:51 +02:00
size_t n = xsnprintf(
csi: the CSI-t family of queries now report unscaled pixel values Before this patch, we reported scaled pixel values. This was rather useless, since applications have no way of getting the scaling factor, to "scale up" e.g. images. Furthermore, the most common use of these queries are probably to calculate the dimensions to use when emitting sixels. Closes #1643
2024-03-14 07:03:51 +01:00
reply, sizeof(reply), "\033[4;%d;%dt", height, width);
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
term_to_slave(term, reply, n);
csi: implement CSI Ps ; Ps ; Ps t reporting escape sequences A lot of the escape sequences on the "CSI Ps ; Ps ; Ps t" form are expected to return a reply. Thus, not having these implemented means we will hang if the client sends these escapes. Not all of these escapes can be meaningfully implemented on Wayland, and thus this implementation is best effort. We now support the following escapes: * 11t - report if window is iconified (always replies "no") * 13t - report window position (always replies 0,0) * 13;2t - report text area position (replies with margins, since we cannot get the window's position) * 14t - report text area size, in pixels * 14;2t - report window size, in pixels * 15t - report screen size, in pixels * 16t - report cell size, in pixels * 18t - report text area size, in cells * 19t - report screen size, in cells
2020-04-17 23:03:20 +02:00
}
csi: implement window and cell size reporting escapes This implements the following queries: * report window size in pixels * report cell size in pixels * report window size in chars We also log a warning for the remaining window operation queries.
2020-02-01 19:27:52 +01:00
break;
}
csi: implement CSI Ps ; Ps ; Ps t reporting escape sequences A lot of the escape sequences on the "CSI Ps ; Ps ; Ps t" form are expected to return a reply. Thus, not having these implemented means we will hang if the client sends these escapes. Not all of these escapes can be meaningfully implemented on Wayland, and thus this implementation is best effort. We now support the following escapes: * 11t - report if window is iconified (always replies "no") * 13t - report window position (always replies 0,0) * 13;2t - report text area position (replies with margins, since we cannot get the window's position) * 14t - report text area size, in pixels * 14;2t - report window size, in pixels * 15t - report screen size, in pixels * 16t - report cell size, in pixels * 18t - report text area size, in cells * 19t - report screen size, in cells
2020-04-17 23:03:20 +02:00
case 15: /* report screen size in pixels */
tll_foreach(term->window->on_outputs, it) {
char reply[64];
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
size_t n = xsnprintf(reply, sizeof(reply), "\033[5;%d;%dt",
csi: the CSI-t family of queries now report unscaled pixel values Before this patch, we reported scaled pixel values. This was rather useless, since applications have no way of getting the scaling factor, to "scale up" e.g. images. Furthermore, the most common use of these queries are probably to calculate the dimensions to use when emitting sixels. Closes #1643
2024-03-14 07:03:51 +01:00
it->item->dim.px_real.height,
it->item->dim.px_real.width);
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
term_to_slave(term, reply, n);
csi: implement CSI Ps ; Ps ; Ps t reporting escape sequences A lot of the escape sequences on the "CSI Ps ; Ps ; Ps t" form are expected to return a reply. Thus, not having these implemented means we will hang if the client sends these escapes. Not all of these escapes can be meaningfully implemented on Wayland, and thus this implementation is best effort. We now support the following escapes: * 11t - report if window is iconified (always replies "no") * 13t - report window position (always replies 0,0) * 13;2t - report text area position (replies with margins, since we cannot get the window's position) * 14t - report text area size, in pixels * 14;2t - report window size, in pixels * 15t - report screen size, in pixels * 16t - report cell size, in pixels * 18t - report text area size, in cells * 19t - report screen size, in cells
2020-04-17 23:03:20 +02:00
break;
}
if (tll_length(term->window->on_outputs) == 0)
term_to_slave(term, "\033[5;0;0t", 8);
break;
csi: implement window and cell size reporting escapes This implements the following queries: * report window size in pixels * report cell size in pixels * report window size in chars We also log a warning for the remaining window operation queries.
2020-02-01 19:27:52 +01:00
case 16: { /* report cell size in pixels */
char reply[64];
term: convert ‘scale’ to a float
2023-06-22 14:21:51 +02:00
size_t n = xsnprintf(
reply, sizeof(reply), "\033[6;%d;%dt",
csi: the CSI-t family of queries now report unscaled pixel values Before this patch, we reported scaled pixel values. This was rather useless, since applications have no way of getting the scaling factor, to "scale up" e.g. images. Furthermore, the most common use of these queries are probably to calculate the dimensions to use when emitting sixels. Closes #1643
2024-03-14 07:03:51 +01:00
term->cell_height, term->cell_width);
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
term_to_slave(term, reply, n);
csi: implement window and cell size reporting escapes This implements the following queries: * report window size in pixels * report cell size in pixels * report window size in chars We also log a warning for the remaining window operation queries.
2020-02-01 19:27:52 +01:00
break;
}
csi: implement CSI Ps ; Ps ; Ps t reporting escape sequences A lot of the escape sequences on the "CSI Ps ; Ps ; Ps t" form are expected to return a reply. Thus, not having these implemented means we will hang if the client sends these escapes. Not all of these escapes can be meaningfully implemented on Wayland, and thus this implementation is best effort. We now support the following escapes: * 11t - report if window is iconified (always replies "no") * 13t - report window position (always replies 0,0) * 13;2t - report text area position (replies with margins, since we cannot get the window's position) * 14t - report text area size, in pixels * 14;2t - report window size, in pixels * 15t - report screen size, in pixels * 16t - report cell size, in pixels * 18t - report text area size, in cells * 19t - report screen size, in cells
2020-04-17 23:03:20 +02:00
case 18: { /* text area size in chars */
csi: implement window and cell size reporting escapes This implements the following queries: * report window size in pixels * report cell size in pixels * report window size in chars We also log a warning for the remaining window operation queries.
2020-02-01 19:27:52 +01:00
char reply[64];
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
size_t n = xsnprintf(reply, sizeof(reply), "\033[8;%d;%dt",
csi: implement window and cell size reporting escapes This implements the following queries: * report window size in pixels * report cell size in pixels * report window size in chars We also log a warning for the remaining window operation queries.
2020-02-01 19:27:52 +01:00
term->rows, term->cols);
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
term_to_slave(term, reply, n);
csi: implement window and cell size reporting escapes This implements the following queries: * report window size in pixels * report cell size in pixels * report window size in chars We also log a warning for the remaining window operation queries.
2020-02-01 19:27:52 +01:00
break;
}
csi: implement CSI Ps ; Ps ; Ps t reporting escape sequences A lot of the escape sequences on the "CSI Ps ; Ps ; Ps t" form are expected to return a reply. Thus, not having these implemented means we will hang if the client sends these escapes. Not all of these escapes can be meaningfully implemented on Wayland, and thus this implementation is best effort. We now support the following escapes: * 11t - report if window is iconified (always replies "no") * 13t - report window position (always replies 0,0) * 13;2t - report text area position (replies with margins, since we cannot get the window's position) * 14t - report text area size, in pixels * 14;2t - report window size, in pixels * 15t - report screen size, in pixels * 16t - report cell size, in pixels * 18t - report text area size, in cells * 19t - report screen size, in cells
2020-04-17 23:03:20 +02:00
case 19: { /* report screen size in chars */
tll_foreach(term->window->on_outputs, it) {
char reply[64];
term: convert ‘scale’ to a float
2023-06-22 14:21:51 +02:00
size_t n = xsnprintf(
reply, sizeof(reply), "\033[9;%d;%dt",
csi: the CSI-t family of queries now report unscaled pixel values Before this patch, we reported scaled pixel values. This was rather useless, since applications have no way of getting the scaling factor, to "scale up" e.g. images. Furthermore, the most common use of these queries are probably to calculate the dimensions to use when emitting sixels. Closes #1643
2024-03-14 07:03:51 +01:00
it->item->dim.px_real.height / term->cell_height,
it->item->dim.px_real.width / term->cell_width);
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
term_to_slave(term, reply, n);
csi: implement CSI Ps ; Ps ; Ps t reporting escape sequences A lot of the escape sequences on the "CSI Ps ; Ps ; Ps t" form are expected to return a reply. Thus, not having these implemented means we will hang if the client sends these escapes. Not all of these escapes can be meaningfully implemented on Wayland, and thus this implementation is best effort. We now support the following escapes: * 11t - report if window is iconified (always replies "no") * 13t - report window position (always replies 0,0) * 13;2t - report text area position (replies with margins, since we cannot get the window's position) * 14t - report text area size, in pixels * 14;2t - report window size, in pixels * 15t - report screen size, in pixels * 16t - report cell size, in pixels * 18t - report text area size, in cells * 19t - report screen size, in cells
2020-04-17 23:03:20 +02:00
break;
}
if (tll_length(term->window->on_outputs) == 0)
term_to_slave(term, "\033[9;0;0t", 8);
break;
}
toplevel-icon: implement OSC-1, CSI 20/21/22/23 t * The toplevel icon is now set to the app-id, unless "overridden" by OSC-1 or OSC-0. * Implemented OSC-1 * OSC-0 extended to also set the icon * Implemented CSI 20 t - report window icon * Implemented CSI 21 t - report window title * Implemented CSI 22 ; 1 t - push window icon * Implemented CS 23 ; 1 t - pop window icon * Extended CSI 22/23 ; 0 t to also push/pop the icon * Verify app-id set by OSC-176 is valid UTF-8 * Verify icon set by OSC-0/1 is valid UTF-8
2024-09-10 18:53:38 +02:00
case 21: {
csi: ignore 'CSI 21 t' - report window title It's not widely used (don't know _any_ application that uses it), and can be used to trick users to run unwanted commands.
2025-01-07 12:58:44 +01:00
#if 0 /* Disabled for now, see #1894 */
toplevel-icon: implement OSC-1, CSI 20/21/22/23 t * The toplevel icon is now set to the app-id, unless "overridden" by OSC-1 or OSC-0. * Implemented OSC-1 * OSC-0 extended to also set the icon * Implemented CSI 20 t - report window icon * Implemented CSI 21 t - report window title * Implemented CSI 22 ; 1 t - push window icon * Implemented CS 23 ; 1 t - pop window icon * Extended CSI 22/23 ; 0 t to also push/pop the icon * Verify app-id set by OSC-176 is valid UTF-8 * Verify icon set by OSC-0/1 is valid UTF-8
2024-09-10 18:53:38 +02:00
char reply[3 + strlen(term->window_title) + 2 + 1];
int chars = xsnprintf(
reply, sizeof(reply), "\033]l%s\033\\", term->window_title);
term_to_slave(term, reply, chars);
csi: ignore 'CSI 21 t' - report window title It's not widely used (don't know _any_ application that uses it), and can be used to trick users to run unwanted commands.
2025-01-07 12:58:44 +01:00
#else
LOG_WARN("CSI 21 t (report window title) ignored");
#endif
toplevel-icon: implement OSC-1, CSI 20/21/22/23 t * The toplevel icon is now set to the app-id, unless "overridden" by OSC-1 or OSC-0. * Implemented OSC-1 * OSC-0 extended to also set the icon * Implemented CSI 20 t - report window icon * Implemented CSI 21 t - report window title * Implemented CSI 22 ; 1 t - push window icon * Implemented CS 23 ; 1 t - pop window icon * Extended CSI 22/23 ; 0 t to also push/pop the icon * Verify app-id set by OSC-176 is valid UTF-8 * Verify icon set by OSC-0/1 is valid UTF-8
2024-09-10 18:53:38 +02:00
break;
}
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
case 22: { /* push window title */
/* 0 - icon + title, 1 - icon, 2 - title */
unsigned what = vt_param_get(term, 1, 0);
if (what == 0 || what == 2) {
tll_push_back(
Convert most dynamic allocations to use functions from xmalloc.h
2020-08-08 20:34:30 +01:00
term->window_title_stack, xstrdup(term->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
}
break;
}
case 23: { /* pop window title */
/* 0 - icon + title, 1 - icon, 2 - title */
unsigned what = vt_param_get(term, 1, 0);
if (what == 0 || what == 2) {
if (tll_length(term->window_title_stack) > 0) {
char *title = tll_pop_back(term->window_title_stack);
term_set_window_title(term, title);
free(title);
}
}
break;
}
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
case 1001: {
}
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
default:
csi: log only the un-handled parameter in a multi-operation CSI Assume we don't handle 'CSI 4 X'. Furthermore, assume we receive the following: 'CSI 1;2;3;4X'. In this case, only log '4X' as un-handled, not the entire CSI string.
2020-02-01 19:42:31 +01:00
LOG_DBG("ignoring %s", csi_as_string(term, final, -1));
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
break;
}
csi: wip: recognize the private CSIs for bracketed paste, smcup/rmxup, smkx/rmkx
2019-06-22 22:25:50 +02:00
break;
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
}
csi: wip: recognize the private CSIs for bracketed paste, smcup/rmxup, smkx/rmkx
2019-06-22 22:25:50 +02:00
csi: implement cursor query and respones
2019-06-23 18:17:36 +02:00
case 'n': {
if (term->vt.params.idx > 0) {
vt/csi: use vt_param_get()
2019-07-10 16:04:16 +02:00
int param = vt_param_get(term, 0, 0);
csi: implement cursor query and respones
2019-06-23 18:17:36 +02:00
switch (param) {
csi: implement 'Query Device Status' By replying with "Device OK"
2019-11-18 11:44:03 +01:00
case 5:
/* Query device status */
term_to_slave(term, "\x1b[0n", 4); /* "Device OK" */
break;
csi: implement cursor query and respones
2019-06-23 18:17:36 +02:00
case 6: {
/* u7 - cursor position query */
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
int row = term->origin == ORIGIN_ABSOLUTE
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
? term->grid->cursor.point.row
: term->grid->cursor.point.row - term->scroll_region.start;
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
csi: implement cursor query and respones
2019-06-23 18:17:36 +02:00
/* TODO: we use 0-based position, while the xterm
* terminfo says the receiver of the reply should
csi: fix cursor request response; add 1, not 2
2019-06-24 19:03:19 +02:00
* decrement, hence we must add 1 */
csi: implement cursor query and respones
2019-06-23 18:17:36 +02:00
char reply[64];
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
size_t n = xsnprintf(reply, sizeof(reply), "\x1b[%d;%dR",
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
row + 1, term->grid->cursor.point.col + 1);
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
term_to_slave(term, reply, n);
csi: implement cursor query and respones
2019-06-23 18:17:36 +02:00
break;
}
default:
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
UNHANDLED();
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
break;
csi: implement cursor query and respones
2019-06-23 18:17:36 +02:00
}
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
} else
UNHANDLED();
csi: implement cursor query and respones
2019-06-23 18:17:36 +02:00
break;
}
wip: vt parsing
2019-06-17 18:57:12 +02:00
default:
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
UNHANDLED();
terminal: only support a single intermediate/private character
2019-07-10 15:03:16 +02:00
break;
wip: vt parsing
2019-06-17 18:57:12 +02:00
}
csi: wip: recognize the private CSIs for bracketed paste, smcup/rmxup, smkx/rmkx
2019-06-22 22:25:50 +02:00
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
break; /* private[0] == 0 */
terminal: only support a single intermediate/private character
2019-07-10 15:03:16 +02:00
}
csi: wip: recognize the private CSIs for bracketed paste, smcup/rmxup, smkx/rmkx
2019-06-22 22:25:50 +02:00
terminal: only support a single intermediate/private character
2019-07-10 15:03:16 +02:00
case '?': {
csi: wip: recognize the private CSIs for bracketed paste, smcup/rmxup, smkx/rmkx
2019-06-22 22:25:50 +02:00
switch (final) {
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
case 'h':
/* DECSET - DEC private mode set */
for (size_t i = 0; i < term->vt.params.idx; i++)
decset(term, term->vt.params.v[i].value);
csi: wip: recognize the private CSIs for bracketed paste, smcup/rmxup, smkx/rmkx
2019-06-22 22:25:50 +02:00
break;
csi: recognize CSI ? 1042/1043 h/l 1042: set 'urgency' window manager hint when receiving ctrl-g 1043: raise window when receiving ctrl-g
2019-11-04 12:00:50 +01:00
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
case 'l':
/* DECRST - DEC private mode reset */
for (size_t i = 0; i < term->vt.params.idx; i++)
decrst(term, term->vt.params.v[i].value);
csi: wip: recognize the private CSIs for bracketed paste, smcup/rmxup, smkx/rmkx
2019-06-22 22:25:50 +02:00
break;
csi: add unknown private escapes 's' and 'r', seen with ncmpcpp
2019-07-03 16:00:27 +02:00
case 's':
csi: implement CSI ? Pm s - XTSAVE
2020-08-16 16:47:46 +02:00
for (size_t i = 0; i < term->vt.params.idx; i++)
xtsave(term, term->vt.params.v[i].value);
csi: ?r and ?s are like ?h and ?l; they save/restore things Assuming ncmpcpp is correct, ?1001s and ?1001r saves and restores the 'highlight mouse tracking' mode.
2019-07-03 21:33:23 +02:00
break;
csi: add unknown private escapes 's' and 'r', seen with ncmpcpp
2019-07-03 16:00:27 +02:00
case 'r':
csi: implement XTRESTORE
2020-08-16 17:02:52 +02:00
for (size_t i = 0; i < term->vt.params.idx; i++)
xtrestore(term, term->vt.params.v[i].value);
csi: add unknown private escapes 's' and 'r', seen with ncmpcpp
2019-07-03 16:00:27 +02:00
break;
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
case 'S': {
config: add tweak option to allow disabling sixels Closes #950
2022-02-27 16:29:35 +01:00
if (!term->conf->tweak.sixel) {
UNHANDLED();
break;
}
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
unsigned target = vt_param_get(term, 0, 0);
unsigned operation = vt_param_get(term, 1, 0);
switch (target) {
case 1:
switch (operation) {
case 1: sixel_colors_report_current(term); break;
case 2: sixel_colors_reset(term); break;
case 3: sixel_colors_set(term, vt_param_get(term, 2, 0)); break;
csi: add 2 missing "break" statements in csi_dispatch()
2020-08-18 20:49:44 +01:00
case 4: sixel_colors_report_max(term); break;
csi: log 'unhandled' for invalid 'target' and 'operation' in CSI ? S
2020-04-25 11:39:31 +02:00
default: UNHANDLED(); break;
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
}
break;
case 2:
sixel: application configurable image max width/height
2020-02-22 21:03:24 +01:00
switch (operation) {
case 1: sixel_geometry_report_current(term); break;
case 2: sixel_geometry_reset(term); break;
case 3: sixel_geometry_set(term, vt_param_get(term, 2, 0), vt_param_get(term, 3, 0)); break;
csi: add 2 missing "break" statements in csi_dispatch()
2020-08-18 20:49:44 +01:00
case 4: sixel_geometry_report_max(term); break;
csi: log 'unhandled' for invalid 'target' and 'operation' in CSI ? S
2020-04-25 11:39:31 +02:00
default: UNHANDLED(); break;
sixel: application configurable image max width/height
2020-02-22 21:03:24 +01:00
}
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
break;
csi: log 'unhandled' for invalid 'target' and 'operation' in CSI ? S
2020-04-25 11:39:31 +02:00
default:
UNHANDLED();
break;
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
}
csi: log 'unhandled' for invalid 'target' and 'operation' in CSI ? S
2020-04-25 11:39:31 +02:00
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
break;
}
csi: implement "CSI ? m"
2023-04-26 18:30:09 +02:00
case 'm': {
int resource = vt_param_get(term, 0, 0);
int value = -1;
switch (resource) {
case 0: /* modifyKeyboard */
value = 0;
break;
case 1: /* modifyCursorKeys */
case 2: /* modifyFunctionKeys */
value = 1;
break;
case 4: /* modifyOtherKeys */
value = term->modify_other_keys_2 ? 2 : 1;
break;
default:
LOG_WARN("XTQMODKEYS: invalid resource '%d' in '%s'",
resource, csi_as_string(term, final, -1));
break;
}
if (value >= 0) {
char reply[16] = {0};
int chars = snprintf(reply, sizeof(reply),
"\033[>%d;%dm", resource, value);
term_to_slave(term, reply, chars);
}
break;
}
csi: implement private mode 2031 (dark/light mode detection) * Recognize 'CSI ? 996 n', and respond with - 'CSI ? 997 ; 1 n' if the primary theme is active - 'CSI ? 997 ; 2 n' if the alternative theme is actice * Implement private mode 2031, where changing the color theme (currently only possible via key bindings) causes the terminal to send the same CSI sequences as above. In this context, foot's primary theme is considered dark, and the alternative theme light (since the default theme is dark). Closes #2025
2025-04-20 12:48:37 +02:00
case 'n': {
const int param = vt_param_get(term, 0, 0);
switch (param) {
case 996: { /* Query current theme mode (see private mode 2031) */
/*
* 1 - dark mode
* 2 - light mode
*
* In foot, the themes aren't necessarily light/dark,
* but by convention, the primary theme is dark, and
* the alternative theme is light.
*/
char reply[16] = {0};
int chars = snprintf(
reply, sizeof(reply),
"\033[?997;%dn",
term->colors.active_theme == COLOR_THEME1 ? 1 : 2);
term_to_slave(term, reply, chars);
break;
}
}
break;
}
csi: support DECRQM queries for ECMA-48 (SM/RM) modes This is in addition to the existing support for DECRQM queries of DEC private modes.
2024-02-11 15:09:28 +00:00
case 'p': {
/*
* Request status of ECMA-48/"ANSI" private mode (DECRQM
* for SM/RM modes; see private="?$" case further below for
* DECSET/DECRST modes)
*/
unsigned param = vt_param_get(term, 0, 0);
unsigned status = DECRPM_NOT_RECOGNIZED;
if (param == 4) {
status = decrpm(term->insert_mode);
}
char reply[32];
size_t n = xsnprintf(reply, sizeof(reply), "\033[%u;%u$y", param, status);
term_to_slave(term, reply, n);
break;
}
kitty kbd: add flag state, implement push/pop/update/query
2021-11-16 16:32:58 +01:00
case 'u': {
enum kitty_kbd_flags flags =
term->grid->kitty_kbd.flags[term->grid->kitty_kbd.idx];
char reply[8];
int chars = snprintf(reply, sizeof(reply), "\033[?%uu", flags);
term_to_slave(term, reply, chars);
break;
}
csi: wip: recognize the private CSIs for bracketed paste, smcup/rmxup, smkx/rmkx
2019-06-22 22:25:50 +02:00
default:
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
UNHANDLED();
break;
csi: wip: recognize the private CSIs for bracketed paste, smcup/rmxup, smkx/rmkx
2019-06-22 22:25:50 +02:00
}
terminal: only support a single intermediate/private character
2019-07-10 15:03:16 +02:00
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
break; /* private[0] == '?' */
csi: wip: recognize the private CSIs for bracketed paste, smcup/rmxup, smkx/rmkx
2019-06-22 22:25:50 +02:00
}
terminal: only support a single intermediate/private character
2019-07-10 15:03:16 +02:00
case '>': {
csi: implement "send device attributes"
2019-06-24 20:01:41 +02:00
switch (final) {
csi: Send Device Attributes, Tertiary DA: require Ps == 0
2019-12-14 14:38:03 +01:00
case 'c':
csi: document "Send Device Attributes (Secondary DA)"
2019-11-18 12:06:29 +01:00
/* Send Device Attributes (Secondary DA) */
csi: Send Device Attributes, Tertiary DA: require Ps == 0
2019-12-14 14:38:03 +01:00
if (vt_param_get(term, 0, 0) != 0) {
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
UNHANDLED();
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
break;
csi: implement "send device attributes"
2019-06-24 20:01:41 +02:00
}
csi: document "Send Device Attributes (Secondary DA)"
2019-11-18 12:06:29 +01:00
/*
* Param 1 - terminal type:
* 0 - vt100
* 1 - vt220
* 2 - vt240
* 18 - vt330
* 19 - vt340
* 24 - vt320
* 41 - vt420
* 61 - vt510
* 64 - vt520
* 65 - vt525
*
* Param 2 - firmware version
* xterm uses its version number. We use an xterm
* version number too, since e.g. Emacs uses this to
* determine level of support.
csi: secondary DA: do not pretend we're xterm Previously, our secondary DA response indicated a) VT420, b) an XTerm version number. Now, we indicate VT220 (which corresponds to the primary DA response), and we report foot's version number as MMmmpp. I.e major, minor and patch versions, using two digits. E.g. 1.4.2 is encoded as 010402
2020-07-24 17:47:47 +02:00
*
* We report ourselves as a VT220. This must be
Fix some spelling mistakes
2020-08-15 19:39:00 +01:00
* synchronized with the primary DA response.
csi: secondary DA: do not pretend we're xterm Previously, our secondary DA response indicated a) VT420, b) an XTerm version number. Now, we indicate VT220 (which corresponds to the primary DA response), and we report foot's version number as MMmmpp. I.e major, minor and patch versions, using two digits. E.g. 1.4.2 is encoded as 010402
2020-07-24 17:47:47 +02:00
*
* Note: tertiary DA replies with "FOOT".
csi: document "Send Device Attributes (Secondary DA)"
2019-11-18 12:06:29 +01:00
*/
csi: secondary DA: do not pretend we're xterm Previously, our secondary DA response indicated a) VT420, b) an XTerm version number. Now, we indicate VT220 (which corresponds to the primary DA response), and we report foot's version number as MMmmpp. I.e major, minor and patch versions, using two digits. E.g. 1.4.2 is encoded as 010402
2020-07-24 17:47:47 +02:00
static_assert(FOOT_MAJOR < 100, "Major version must not exceed 99");
static_assert(FOOT_MINOR < 100, "Minor version must not exceed 99");
static_assert(FOOT_PATCH < 100, "Patch version must not exceed 99");
char reply[64];
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
size_t n = xsnprintf(reply, sizeof(reply), "\033[>1;%02u%02u%02u;0c",
csi: secondary DA: do not pretend we're xterm Previously, our secondary DA response indicated a) VT420, b) an XTerm version number. Now, we indicate VT220 (which corresponds to the primary DA response), and we report foot's version number as MMmmpp. I.e major, minor and patch versions, using two digits. E.g. 1.4.2 is encoded as 010402
2020-07-24 17:47:47 +02:00
FOOT_MAJOR, FOOT_MINOR, FOOT_PATCH);
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
term_to_slave(term, reply, n);
performance improvements * action() returns void - this gets rid of checks in vt_from_slave() * split up ACTION_PRINT into ACTION_PRINT (ASCII) and ACTION_UTF8_PRINT ACTION_PRINT is on the hot path, and we want it streamlined. * Remove run-time checkout for unimplemented state transitions, as we shouldn't have any of those left. * Don't re-load current VT state on each iteration in vt_from_slave()
2019-07-07 16:32:18 +02:00
break;
csi: implement "send device attributes"
2019-06-24 20:01:41 +02:00
csi: recognize, but ignore, modifyOtherKeys et al resource setters
2019-07-18 19:48:37 +02:00
case 'm':
if (term->vt.params.idx == 0) {
/* Reset all */
} else {
int resource = vt_param_get(term, 0, 0);
csi: add 'unimplemented' warnings for things we handle but ignore
2019-08-04 18:11:59 +02:00
int value = vt_param_get(term, 1, -1);
csi: recognize, but ignore, modifyOtherKeys et al resource setters
2019-07-18 19:48:37 +02:00
switch (resource) {
case 0: /* modifyKeyboard */
csi: add 'unimplemented' warnings for things we handle but ignore
2019-08-04 18:11:59 +02:00
break;
csi: recognize, but ignore, modifyOtherKeys et al resource setters
2019-07-18 19:48:37 +02:00
case 1: /* modifyCursorKeys */
case 2: /* modifyFunctionKeys */
/* Ignored, we always report modifiers */
input: add support for modifyOtherKeys=2 Similar to modifyOtherKeys=1 (foot’s default, and only, mode), except that: * All modifiers (and not just Ctrl) generate \E[27;m;n~ escapes * Regular keys (with modifiers) also generate \E[27;m;n~ escapes (for example, C-h no longer generates ^H, but \E[27;5;104~) For our keymap based lookups, this is handled by adding MOD_MODIFY_OTHER_KEYS_STATE<N> variants. For “generic” keys, we simply adjust the conditions for when to emit a \E[27;m;n~ escape - the only requirement is that at least one modifier is active.
2021-11-11 17:43:39 +01:00
if (value != 2 && value != -1) {
LOG_WARN(
"unimplemented: %s = %d",
resource == 1 ? "modifyCursorKeys" :
resource == 2 ? "modifyFunctionKeys" : "<invalid>",
value);
csi: add 'unimplemented' warnings for things we handle but ignore
2019-08-04 18:11:59 +02:00
}
csi: recognize, but ignore, modifyOtherKeys et al resource setters
2019-07-18 19:48:37 +02:00
break;
input: add support for modifyOtherKeys=2 Similar to modifyOtherKeys=1 (foot’s default, and only, mode), except that: * All modifiers (and not just Ctrl) generate \E[27;m;n~ escapes * Regular keys (with modifiers) also generate \E[27;m;n~ escapes (for example, C-h no longer generates ^H, but \E[27;5;104~) For our keymap based lookups, this is handled by adding MOD_MODIFY_OTHER_KEYS_STATE<N> variants. For “generic” keys, we simply adjust the conditions for when to emit a \E[27;m;n~ escape - the only requirement is that at least one modifier is active.
2021-11-11 17:43:39 +01:00
case 4: /* modifyOtherKeys */
term->modify_other_keys_2 = value == 2;
LOG_DBG("modifyOtherKeys=%d", value);
break;
csi: recognize, but ignore, modifyOtherKeys et al resource setters
2019-07-18 19:48:37 +02:00
default:
csi: implement "CSI ? m"
2023-04-26 18:30:09 +02:00
LOG_WARN("XTMODKEYS: invalid resource '%d' in '%s'",
csi: log only the un-handled parameter in a multi-operation CSI Assume we don't handle 'CSI 4 X'. Furthermore, assume we receive the following: 'CSI 1;2;3;4X'. In this case, only log '4X' as un-handled, not the entire CSI string.
2020-02-01 19:42:31 +01:00
resource, csi_as_string(term, final, -1));
csi: recognize, but ignore, modifyOtherKeys et al resource setters
2019-07-18 19:48:37 +02:00
break;
}
}
break; /* final == 'm' */
csi: implement CSI > 4n (reset modifyOtherKeys)
2022-04-19 17:25:06 +02:00
case 'n': {
fix typos
2023-03-29 00:31:49 +03:00
int resource = vt_param_get(term, 0, 2); /* Default is modifyFunctionKeys */
csi: implement CSI > 4n (reset modifyOtherKeys)
2022-04-19 17:25:06 +02:00
switch (resource) {
case 0: /* modifyKeyboard */
case 1: /* modifyCursorKeys */
case 2: /* modifyFunctionKeys */
break;
case 4: /* modifyOtherKeys */
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
/* We don't support fully disabling modifyOtherKeys,
* but simply revert back to mode '1' */
csi: implement CSI > 4n (reset modifyOtherKeys)
2022-04-19 17:25:06 +02:00
term->modify_other_keys_2 = false;
LOG_DBG("modifyOtherKeys=1");
break;
}
break;
}
kitty kbd: add flag state, implement push/pop/update/query
2021-11-16 16:32:58 +01:00
case 'u': {
term: rename: KITTY_KBD_MASK -> KITTY_KBD_SUPPORTED
2021-11-22 22:42:49 +01:00
int flags = vt_param_get(term, 0, 0) & KITTY_KBD_SUPPORTED;
kitty kbd: add flag state, implement push/pop/update/query
2021-11-16 16:32:58 +01:00
struct grid *grid = term->grid;
uint8_t idx = grid->kitty_kbd.idx;
if (idx + 1 >= ALEN(grid->kitty_kbd.flags)) {
/* Stack full, evict oldest by wrapping around */
idx = 0;
} else
idx++;
grid->kitty_kbd.flags[idx] = flags;
grid->kitty_kbd.idx = idx;
csi: kitty: s/mode/flags in debug logs
2021-11-16 16:37:10 +01:00
LOG_DBG("kitty kbd: pushed new flags: 0x%03x", flags);
kitty kbd: add flag state, implement push/pop/update/query
2021-11-16 16:32:58 +01:00
break;
}
csi: implement XTVERSION (CSI > 0q) This is a fairly new XTerm extension. The reply is on the format: DCS > | text ST XTerm replies with ‘text’ = “XTerm(366)”. Foot replies with ‘text’ = “foot(1.6.4)” Closes #359
2021-02-16 12:00:58 +01:00
case 'q': {
/* XTVERSION */
if (vt_param_get(term, 0, 0) != 0) {
UNHANDLED();
break;
}
char reply[64];
size_t n = xsnprintf(
reply, sizeof(reply), "\033P>|foot(%u.%u.%u%s%s)\033\\",
FOOT_MAJOR, FOOT_MINOR, FOOT_PATCH,
FOOT_EXTRA[0] != '\0' ? "-" : "", FOOT_EXTRA);
term_to_slave(term, reply, n);
break;
}
csi: implement "send device attributes"
2019-06-24 20:01:41 +02:00
default:
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
UNHANDLED();
csi: add missing 'break'
2019-07-16 10:20:47 +02:00
break;
csi: implement "send device attributes"
2019-06-24 20:01:41 +02:00
}
terminal: only support a single intermediate/private character
2019-07-10 15:03:16 +02:00
vt: don’t ignore extra private/intermediate characters Take ‘\E(#0’ for example - this is *not* the same as ‘\E(0’. Up until now, foot has however treated them as the same escape, because the handler for ‘\E(0’ didn’t verify there weren’t any _other_ private characters present. Fix this by turning the ‘private’ array into a single 4-byte integer. This allows us to match *all* privates with a single comparison. Private characters are added to the LSB first, and MSB last. This means we can check for single privates in pretty much the same way as before: switch (term->vt.private) { case ‘?’: ... break; } Checking for two (or more) is much uglier, but foot only supports a *single* escape with two privates, and no escapes with three or more: switch (term->vt.private) { case 0x243f: /* ‘?$’ */ ... break; } The ‘clear’ action remains simple (and fast), with a single write operation. Collecting privates is potentially _slightly_ more complex than before; we now need mask and compare, instead of simply comparing, when checking how many privates we already have. We _could_ add a counter, which would make collecting privates easier, but this would add an additional write to the ‘clean’ action which is really bad since it’s in the hot path.
2020-12-16 14:30:49 +01:00
break; /* private[0] == '>' */
csi: implement "send device attributes"
2019-06-24 20:01:41 +02:00
}
kitty kbd: add flag state, implement push/pop/update/query
2021-11-16 16:32:58 +01:00
case '<': {
switch (final) {
case 'u': {
int count = vt_param_get(term, 0, 1);
LOG_DBG("kitty kbd: popping %d levels of flags", count);
struct grid *grid = term->grid;
uint8_t idx = grid->kitty_kbd.idx;
for (int i = 0; i < count; i++) {
/* Reset flags. This ensures we get flags=0 when
* over-popping */
grid->kitty_kbd.flags[idx] = 0;
if (idx == 0)
idx = ALEN(grid->kitty_kbd.flags) - 1;
else
idx--;
}
grid->kitty_kbd.idx = idx;
csi: kitty: s/mode/flags in debug logs
2021-11-16 16:37:10 +01:00
LOG_DBG("kitty kbd: flags after pop: 0x%03x",
kitty kbd: add flag state, implement push/pop/update/query
2021-11-16 16:32:58 +01:00
term->grid->kitty_kbd.flags[idx]);
break;
}
}
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
break; /* private[0] == '<' */
kitty kbd: add flag state, implement push/pop/update/query
2021-11-16 16:32:58 +01:00
}
csi: recognize, but mostly ignore, cursor style configuration
2019-07-16 10:20:54 +02:00
case ' ': {
switch (final) {
case 'q': {
int param = vt_param_get(term, 0, 0);
switch (param) {
csi: '\E[0 q' resets the cursor style to the default, not '\E[2 q' Also update 'Se' capability in the terminfo, to reflect this.
2020-06-30 17:43:43 +02:00
case 0: /* blinking block, but we use it to reset to configured default */
term: remove read-only properties copied from the config Use the config directly instead.
2020-11-26 18:08:28 +01:00
term->cursor_style = term->conf->cursor.style;
config: add cursor.blink-rate option The default is 500ms, which corresponds to the old, hardcoded default. Closes #1707
2024-05-20 09:03:29 +02:00
term->cursor_blink.deccsusr = term->conf->cursor.blink.enabled;
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
term_cursor_blink_update(term);
csi: let CSI 0 q mean "switch to user configured cursor style" According to the specs, \E[0 q means a blinking block cursor. However, since it also states that \E[1 q *also* is a blinking block cursor, and that it is the default, *and* given that fact that parameter-less CSIs typically means "reset", let's make it mean "reset to the user configured cursor style".
2019-07-22 20:19:27 +02:00
break;
csi: '\E[0 q' resets the cursor style to the default, not '\E[2 q' Also update 'Se' capability in the terminfo, to reflect this.
2020-06-30 17:43:43 +02:00
case 1: /* blinking block */
case 2: /* steady block */
DECSCUSR+DECRQSS: treat hollow cursor as a block cursor If the user has configured cursor.style=hollow, make DECSCUSR 1/2 set the cursor to hollow rather than block, and make DECRQSS DECSCUSR respond as if cursor.style=block. The idea is to not expose the hollow variant in DECSCUSR in any way, to avoid having to extend it with custom encodings. Another way to think about it is this is just a slightly more discoverable way of doing: cursor.style=block cursor.block-cursor-is-hollow=yes
2025-02-21 08:03:41 +01:00
term->cursor_style = term->conf->cursor.style == CURSOR_HOLLOW
? CURSOR_HOLLOW : CURSOR_BLOCK;
csi: recognize, but mostly ignore, cursor style configuration
2019-07-16 10:20:54 +02:00
break;
csi: prepare for alternative cursor styles
2019-07-22 19:44:21 +02:00
case 3: /* blinking underline */
case 4: /* steady underline */
term->cursor_style = CURSOR_UNDERLINE;
break;
case 5: /* blinking bar */
case 6: /* steady bar */
config: add ‘beam-thickness’ option * Rename cursor.style value ‘bar’ to ‘beam’. ‘bar’ remains recognized, but should eventually be deprecated and then removed. * Add ‘cursor.beam-thickness’ option, a pt-or-px value specifying the thickness of the beam cursor. Defaults to 1.5pt. * Rename (and export) pt_or_px_as_pixels() to term_pt_or_px_as_pixels() * Change term_pt_or_px_as_pixels() to round point values instead of truncating them.
2021-04-30 20:31:47 +02:00
term->cursor_style = CURSOR_BEAM;
csi: recognize, but mostly ignore, cursor style configuration
2019-07-16 10:20:54 +02:00
break;
csi: ignore invalid parameters in 'CSI Ps <space> q' Before this patch, an invalid parameter would not change the cursor style, but could cause the cursor to start (or stop) blinking.
2020-05-04 20:19:24 +02:00
default:
UNHANDLED();
break;
csi: recognize, but mostly ignore, cursor style configuration
2019-07-16 10:20:54 +02:00
}
csi: prepare for alternative cursor styles
2019-07-22 19:44:21 +02:00
csi: '\E[0 q' resets the cursor style to the default, not '\E[2 q' Also update 'Se' capability in the terminfo, to reflect this.
2020-06-30 17:43:43 +02:00
if (param > 0 && param <= 6) {
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
term->cursor_blink.deccsusr = param & 1;
term_cursor_blink_update(term);
csi: ignore invalid parameters in 'CSI Ps <space> q' Before this patch, an invalid parameter would not change the cursor style, but could cause the cursor to start (or stop) blinking.
2020-05-04 20:19:24 +02:00
}
csi: recognize, but mostly ignore, cursor style configuration
2019-07-16 10:20:54 +02:00
break;
}
default:
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
UNHANDLED();
csi: recognize, but mostly ignore, cursor style configuration
2019-07-16 10:20:54 +02:00
break;
}
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
break; /* private[0] == ' ' */
csi: recognize, but mostly ignore, cursor style configuration
2019-07-16 10:20:54 +02:00
}
vt/csi: recognize the reset sequence sent by 'reset' However, we don't (yet) actually reset the terminal
2019-07-17 10:39:38 +02:00
case '!': {
csi: various, minor code/formatting improvements
2021-08-30 07:40:03 +01:00
if (final == 'p') {
term: implement reset
2019-08-01 20:51:11 +02:00
term_reset(term, false);
vt/csi: recognize the reset sequence sent by 'reset' However, we don't (yet) actually reset the terminal
2019-07-17 10:39:38 +02:00
break;
}
csi: various, minor code/formatting improvements
2021-08-30 07:40:03 +01:00
UNHANDLED();
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
break; /* private[0] == '!' */
vt/csi: recognize the reset sequence sent by 'reset' However, we don't (yet) actually reset the terminal
2019-07-17 10:39:38 +02:00
}
csi: implement "Send Device Attributes (Tertiary DA)"
2019-11-18 12:46:52 +01:00
case '=': {
switch (final) {
case 'c':
csi: Send Device Attributes, Tertiary DA: require Ps == 0
2019-12-14 14:38:03 +01:00
if (vt_param_get(term, 0, 0) != 0) {
UNHANDLED();
break;
}
csi: describe format of reply to tertiary DA
2019-12-14 19:10:59 +01:00
/*
* Send Device Attributes (Tertiary DA)
*
* Reply format is "DCS ! | DDDDDDDD ST"
*
* D..D is the unit ID of the terminal, consisting of four
* hexadecimal pairs. The first pair represents the
* manufacturing site code. This code can be any
* hexadecimal value from 00 through FF.
*/
csi: implement "Send Device Attributes (Tertiary DA)"
2019-11-18 12:46:52 +01:00
csi: change DA3 reply to "FOOT", in hex
2019-12-21 20:35:55 +01:00
term_to_slave(term, "\033P!|464f4f54\033\\", 14); /* FOOT */
csi: implement "Send Device Attributes (Tertiary DA)"
2019-11-18 12:46:52 +01:00
break;
kitty kbd: add flag state, implement push/pop/update/query
2021-11-16 16:32:58 +01:00
case 'u': {
term: rename: KITTY_KBD_MASK -> KITTY_KBD_SUPPORTED
2021-11-22 22:42:49 +01:00
int flag_set = vt_param_get(term, 0, 0) & KITTY_KBD_SUPPORTED;
kitty kbd: add flag state, implement push/pop/update/query
2021-11-16 16:32:58 +01:00
int mode = vt_param_get(term, 1, 1);
struct grid *grid = term->grid;
uint8_t idx = grid->kitty_kbd.idx;
switch (mode) {
case 1:
/* set bits are set, unset bits are reset */
grid->kitty_kbd.flags[idx] = flag_set;
break;
case 2:
/* set bits are set, unset bits are left unchanged */
grid->kitty_kbd.flags[idx] |= flag_set;
break;
case 3:
/* set bits are reset, unset bits are left unchanged */
grid->kitty_kbd.flags[idx] &= ~flag_set;
break;
default:
UNHANDLED();
break;
}
csi: kitty: log flags after ‘update’ operation
2021-11-16 16:37:23 +01:00
LOG_DBG("kitty kbd: flags after update: 0x%03x",
grid->kitty_kbd.flags[idx]);
kitty kbd: add flag state, implement push/pop/update/query
2021-11-16 16:32:58 +01:00
break;
}
csi: implement "Send Device Attributes (Tertiary DA)"
2019-11-18 12:46:52 +01:00
default:
UNHANDLED();
break;
}
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
break; /* private[0] == '=' */
csi: implement "Send Device Attributes (Tertiary DA)"
2019-11-18 12:46:52 +01:00
}
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
case '$': {
switch (final) {
case 'r': { /* DECCARA */
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
int top, left, bottom, right;
if (!params_to_rectangular_area(
term, 0, &top, &left, &bottom, &right))
{
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
break;
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
}
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
for (int r = top; r <= bottom; r++) {
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
struct row *row = grid_row(term->grid, r);
csi: DECCARA+DECRARA: dirty cells
2021-12-28 17:14:50 +01:00
row->dirty = true;
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
for (int c = left; c <= right; c++) {
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
struct attributes *a = &row->cells[c].attrs;
csi: DECCARA+DECRARA: dirty cells
2021-12-28 17:14:50 +01:00
a->clean = 0;
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
for (size_t i = 4; i < term->vt.params.idx; i++) {
const int param = term->vt.params.v[i].value;
/* DECCARA only supports a sub-set of SGR parameters */
switch (param) {
case 0:
a->bold = false;
a->underline = false;
a->blink = false;
a->reverse = false;
break;
case 1: a->bold = true; break;
case 4: a->underline = true; break;
case 5: a->blink = true; break;
case 7: a->reverse = true; break;
case 22: a->bold = false; break;
case 24: a->underline = false; break;
case 25: a->blink = false; break;
case 27: a->reverse = false; break;
}
}
}
}
break;
}
case 't': { /* DECRARA */
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
int top, left, bottom, right;
if (!params_to_rectangular_area(
term, 0, &top, &left, &bottom, &right))
{
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
break;
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
}
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
for (int r = top; r <= bottom; r++) {
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
struct row *row = grid_row(term->grid, r);
csi: DECCARA+DECRARA: dirty cells
2021-12-28 17:14:50 +01:00
row->dirty = true;
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
for (int c = left; c <= right; c++) {
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
struct attributes *a = &row->cells[c].attrs;
csi: DECCARA+DECRARA: dirty cells
2021-12-28 17:14:50 +01:00
a->clean = 0;
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
for (size_t i = 4; i < term->vt.params.idx; i++) {
const int param = term->vt.params.v[i].value;
csi: DECRARA: fix comment: DECCARA -> DECRARA
2021-12-26 16:37:11 +01:00
/* DECRARA only supports a sub-set of SGR parameters */
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
switch (param) {
case 0:
a->bold = !a->bold;
a->underline = !a->underline;
a->blink = !a->blink;
a->reverse = !a->reverse;
break;
case 1: a->bold = !a->bold; break;
case 4: a->underline = !a->underline; break;
case 5: a->blink = !a->blink; break;
case 7: a->reverse = !a->reverse; break;
}
}
}
}
break;
}
case 'v': { /* DECCRA */
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
int src_top, src_left, src_bottom, src_right;
if (!params_to_rectangular_area(
term, 0, &src_top, &src_left, &src_bottom, &src_right))
{
break;
}
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
int src_page = vt_param_get(term, 4, 1);
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
int dst_rel_top = vt_param_get(term, 5, 1) - 1;
int dst_left = vt_param_get(term, 6, 1) - 1;
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
int dst_page = vt_param_get(term, 7, 1);
if (unlikely(src_page != 1 || dst_page != 1)) {
/* We don’t support “pages” */
break;
}
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
int dst_rel_bottom = dst_rel_top + (src_bottom - src_top);
int dst_right = min(dst_left + (src_right - src_left), term->cols - 1);
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
int dst_top = term_row_rel_to_abs(term, dst_rel_top);
int dst_bottom = term_row_rel_to_abs(term, dst_rel_bottom);
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
/* Target area outside the screen is clipped */
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
const size_t row_count = min(src_bottom - src_top,
dst_bottom - dst_top) + 1;
const size_t cell_count = min(src_right - src_left,
dst_right - dst_left) + 1;
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
sixel_overwrite_by_rectangle(
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
term, dst_top, dst_left, row_count, cell_count);
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
/*
* Copy source area
*
* Note: since source and destination may overlap, we need
* to copy out the entire source region first, and _then_
* write the destination. I.e. this is similar to how
* memmove() behaves, but adapted to our row/cell
* structure.
*/
struct cell **copy = xmalloc(row_count * sizeof(copy[0]));
for (int r = 0; r < row_count; r++) {
copy[r] = xmalloc(cell_count * sizeof(copy[r][0]));
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
const struct row *row = grid_row(term->grid, src_top + r);
const struct cell *cell = &row->cells[src_left];
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
memcpy(copy[r], cell, cell_count * sizeof(copy[r][0]));
}
/* Paste into destination area */
for (int r = 0; r < row_count; r++) {
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
struct row *row = grid_row(term->grid, dst_top + r);
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
row->dirty = true;
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
struct cell *cell = &row->cells[dst_left];
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
memcpy(cell, copy[r], cell_count * sizeof(copy[r][0]));
free(copy[r]);
csi: DECCRA: no need for a counter here
2021-12-26 16:25:52 +01:00
for (;cell < &row->cells[dst_left + cell_count]; cell++)
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
cell->attrs.clean = 0;
if (unlikely(row->extra != NULL)) {
/* TODO: technically, we should copy the source URIs... */
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
grid_row_uri_range_erase(row, dst_left, dst_right);
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
}
}
free(copy);
break;
}
case 'x': { /* DECFRA */
term_fill(): change ‘character’ parameter from char -> uint8_t
2021-12-26 16:13:05 +01:00
const uint8_t c = vt_param_get(term, 0, 0);
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
term_fill(): change ‘character’ parameter from char -> uint8_t
2021-12-26 16:13:05 +01:00
if (unlikely(!((c >= 32 && c < 126) || c >= 160)))
break;
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
term_fill(): change ‘character’ parameter from char -> uint8_t
2021-12-26 16:13:05 +01:00
int top, left, bottom, right;
if (!params_to_rectangular_area(
term, 1, &top, &left, &bottom, &right))
{
break;
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
}
term_fill(): change ‘character’ parameter from char -> uint8_t
2021-12-26 16:13:05 +01:00
/* Erase the entire region at once (MUCH cheaper than
* doing it row by row, or even character by
* character). */
sixel_overwrite_by_rectangle(
term, top, left, bottom - top + 1, right - left + 1);
for (int r = top; r <= bottom; r++)
term_fill(term, r, left, c, right - left + 1, true);
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
break;
}
case 'z': { /* DECERA */
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
int top, left, bottom, right;
if (!params_to_rectangular_area(
term, 0, &top, &left, &bottom, &right))
{
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
break;
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
}
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
/*
* Note: term_erase() _also_ erases sixels, but since
* we’re forced to erase one row at a time, erasing the
* entire sixel here is more efficient.
*/
sixel_overwrite_by_rectangle(
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
term, top, left, bottom - top + 1, right - left + 1);
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
csi: rectangular: add helper function params_to_rectangular_area() This functions reads the four top/left/bottom/right parameters, validates them, and converts relative row numbers to absolute. Returns true if the params are valid, otherwise false.
2021-12-26 15:53:46 +01:00
for (int r = top; r <= bottom; r++)
term_erase(term, r, left, r, right);
csi: implement rectangular edit escapes * DECCARA - change attributes in rectangular area * DECRARA - reverse attributes in rectangular area * DECCRA - copy rectangular area * DECFRA - fill rectangular area * DECERA - erase rectangular area Not implemented: * DECSERA - selective erase rectangular area
2021-12-26 15:00:27 +01:00
break;
}
}
break; /* private[0] == ‘$’ */
}
csi: implement XTPUSHCOLORS+XTPOPCOLORS+XTREPORTCOLORS The documentation of these sequences are vague and lacking, as is often the case with XTerm invented control sequences. I've tried to replicate what XTerm does (as of xterm-392). The stack represents *stashed/stored* palettes. The currently active palette is *not* stored on the stack. The stack is dynamically allocated, and starts out with zero elements. Now, XTerm has a somewhat weird definition of "pushing" and "popping" in this context, and the documentation is somewhat misleading. What a push does is this: it stores the current palette to the stack at the specified slot. If the specified slot number (Pm) is 0, the slot used is the current slot index incremented by 1. The "current" slot index is then set to the specified slot (which is current slot + 1 if Pm == 0). Thus, "push" (i.e. when Pm == 0 is used) means store to the "next" slot. This is true even if the current slot index points into the middle of stack. Pop works in a similar way. The palette is restored from the specified slot index. If the specified slot number is 0, we use the current slot index. The "current" slot index is then set to the specified slot - 1 (current slot - 1 if Pm == 0). XTREPORTCOLORS return the current slot index, and the number of palettes stored on the stack, on the format CSI ? <slot index> ; <palette count> # Q When XTPUSHCOLORS grows the stack with more than one element (i.e. via a 'CSI N # P' sequence), make sure *all* new slots are initialized (to the current color palette). This avoids uninitialized slots, that could then be popped with XTPOPCOLORS. Closes #856
2024-07-01 17:40:45 +02:00
case '#': {
switch (final) {
case 'P': { /* XTPUSHCOLORS */
int slot = vt_param_get(term, 0, 0);
/* Pm == 0, "push" (what xterm does is take take the
*current* slot + 1, even if that's in the middle of the
stack, and overwrites whatever is already in that
slot) */
if (slot == 0)
slot = term->color_stack.idx + 1;
if (term->color_stack.size < slot) {
const size_t new_size = slot;
term->color_stack.stack = xrealloc(
term->color_stack.stack,
new_size * sizeof(term->color_stack.stack[0]));
/* Initialize new slots (except the selected slot,
which is done below) */
xassert(new_size > 0);
for (size_t i = term->color_stack.size; i < new_size - 1; i++) {
memcpy(&term->color_stack.stack[i], &term->colors,
sizeof(term->colors));
}
term->color_stack.size = new_size;
}
xassert(slot > 0);
xassert(slot <= term->color_stack.size);
term->color_stack.idx = slot;
memcpy(&term->color_stack.stack[slot - 1], &term->colors,
sizeof(term->colors));
break;
}
case 'Q': { /* XTPOPCOLORS */
int slot = vt_param_get(term, 0, 0);
/* Pm == 0, "pop" (what xterm does is copy colors from the
*current* slot, *and* decrease the current slot index,
even if that's in the middle of the stack) */
if (slot == 0)
slot = term->color_stack.idx;
if (slot > 0 && slot <= term->color_stack.size) {
memcpy(&term->colors, &term->color_stack.stack[slot - 1],
sizeof(term->colors));
term->color_stack.idx = slot - 1;
osc: extend damage-cells-by-color to default fg/bg as well When changing part of the color palette, through either OSC-4, or OSC-10 and OSC-11 (and the corresponding reset OSCs: 104, 110 and 111), only dirty affected cells. We've always done this, but only for OSC-4. This patch breaks out that logic, and extends it to handle default fg/bg too. It also fixes a bug where cells with colored underlines were not dirtied if the underline was the only part of the cell that was affected by a OSC-4 change.
2024-07-03 10:53:33 +02:00
/* Assume a full palette switch *will* affect almost
all cells. The alternative is to call
term_damage_color() for all 256 palette entries
*and* the default fg/bg (256 + 2 calls in total) */
csi: implement XTPUSHCOLORS+XTPOPCOLORS+XTREPORTCOLORS The documentation of these sequences are vague and lacking, as is often the case with XTerm invented control sequences. I've tried to replicate what XTerm does (as of xterm-392). The stack represents *stashed/stored* palettes. The currently active palette is *not* stored on the stack. The stack is dynamically allocated, and starts out with zero elements. Now, XTerm has a somewhat weird definition of "pushing" and "popping" in this context, and the documentation is somewhat misleading. What a push does is this: it stores the current palette to the stack at the specified slot. If the specified slot number (Pm) is 0, the slot used is the current slot index incremented by 1. The "current" slot index is then set to the specified slot (which is current slot + 1 if Pm == 0). Thus, "push" (i.e. when Pm == 0 is used) means store to the "next" slot. This is true even if the current slot index points into the middle of stack. Pop works in a similar way. The palette is restored from the specified slot index. If the specified slot number is 0, we use the current slot index. The "current" slot index is then set to the specified slot - 1 (current slot - 1 if Pm == 0). XTREPORTCOLORS return the current slot index, and the number of palettes stored on the stack, on the format CSI ? <slot index> ; <palette count> # Q When XTPUSHCOLORS grows the stack with more than one element (i.e. via a 'CSI N # P' sequence), make sure *all* new slots are initialized (to the current color palette). This avoids uninitialized slots, that could then be popped with XTPOPCOLORS. Closes #856
2024-07-01 17:40:45 +02:00
term_damage_view(term);
csi: redraw margins after restoring the palette
2024-07-01 19:29:54 +02:00
term_damage_margins(term);
csi: implement XTPUSHCOLORS+XTPOPCOLORS+XTREPORTCOLORS The documentation of these sequences are vague and lacking, as is often the case with XTerm invented control sequences. I've tried to replicate what XTerm does (as of xterm-392). The stack represents *stashed/stored* palettes. The currently active palette is *not* stored on the stack. The stack is dynamically allocated, and starts out with zero elements. Now, XTerm has a somewhat weird definition of "pushing" and "popping" in this context, and the documentation is somewhat misleading. What a push does is this: it stores the current palette to the stack at the specified slot. If the specified slot number (Pm) is 0, the slot used is the current slot index incremented by 1. The "current" slot index is then set to the specified slot (which is current slot + 1 if Pm == 0). Thus, "push" (i.e. when Pm == 0 is used) means store to the "next" slot. This is true even if the current slot index points into the middle of stack. Pop works in a similar way. The palette is restored from the specified slot index. If the specified slot number is 0, we use the current slot index. The "current" slot index is then set to the specified slot - 1 (current slot - 1 if Pm == 0). XTREPORTCOLORS return the current slot index, and the number of palettes stored on the stack, on the format CSI ? <slot index> ; <palette count> # Q When XTPUSHCOLORS grows the stack with more than one element (i.e. via a 'CSI N # P' sequence), make sure *all* new slots are initialized (to the current color palette). This avoids uninitialized slots, that could then be popped with XTPOPCOLORS. Closes #856
2024-07-01 17:40:45 +02:00
} else if (slot == 0) {
LOG_ERR("XTPOPCOLORS: cannot pop beyond the first element");
} else {
LOG_ERR(
"XTPOPCOLORS: invalid color slot: %d "
"(stack has %zu slots, current slot is %zu)",
vt_param_get(term, 0, 0),
term->color_stack.size, term->color_stack.idx);
}
break;
}
case 'R': { /* XTREPORTCOLORS */
char reply[64];
xsnprintf: various improvements related to xvsnprintf() and xsnprintf() Summary of changes: * Make xvsnprintf() static * restrict-qualify pointer arguments (as done by the libc equivalents) * Make comments and spec references more thorough * Remove pointless `n <= INT_MAX` assertion (see comment) * Use FATAL_ERROR() instead of xassert() (since the assertion is inside a shared util function but the caller is responsible for ensuring the condition holds true) * Change some callers to use size_t instead of int for the return value (negative returns are impossible and all subsequent uses are size_t) The updated comments and code were taken (and adapted) from: https://gitlab.com/craigbarnes/dte/-/blob/49260bb154bca0434462a41c061e512540ec2e49/src/util/xsnprintf.c#L6-50 This work was entirely authored by me and I hereby license this contribution under the MIT license (stated explicitly, so that there's no ambiguity w.r.t. the original license).
2024-09-11 20:13:30 +01:00
size_t n = xsnprintf(reply, sizeof(reply), "\033[?%zu;%zu#Q",
csi: implement XTPUSHCOLORS+XTPOPCOLORS+XTREPORTCOLORS The documentation of these sequences are vague and lacking, as is often the case with XTerm invented control sequences. I've tried to replicate what XTerm does (as of xterm-392). The stack represents *stashed/stored* palettes. The currently active palette is *not* stored on the stack. The stack is dynamically allocated, and starts out with zero elements. Now, XTerm has a somewhat weird definition of "pushing" and "popping" in this context, and the documentation is somewhat misleading. What a push does is this: it stores the current palette to the stack at the specified slot. If the specified slot number (Pm) is 0, the slot used is the current slot index incremented by 1. The "current" slot index is then set to the specified slot (which is current slot + 1 if Pm == 0). Thus, "push" (i.e. when Pm == 0 is used) means store to the "next" slot. This is true even if the current slot index points into the middle of stack. Pop works in a similar way. The palette is restored from the specified slot index. If the specified slot number is 0, we use the current slot index. The "current" slot index is then set to the specified slot - 1 (current slot - 1 if Pm == 0). XTREPORTCOLORS return the current slot index, and the number of palettes stored on the stack, on the format CSI ? <slot index> ; <palette count> # Q When XTPUSHCOLORS grows the stack with more than one element (i.e. via a 'CSI N # P' sequence), make sure *all* new slots are initialized (to the current color palette). This avoids uninitialized slots, that could then be popped with XTPOPCOLORS. Closes #856
2024-07-01 17:40:45 +02:00
term->color_stack.idx, term->color_stack.size);
term_to_slave(term, reply, n);
break;
}
}
break; /* private[0] == '#' */
}
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
case 0x243f: /* ?$ */
switch (final) {
case 'p': {
unsigned param = vt_param_get(term, 0, 0);
/*
* Request DEC private mode (DECRQM)
* Reply:
* 0 - not recognized
* 1 - set
* 2 - reset
* 3 - permanently set
* 4 - permantently reset
*/
csi: reply with 4 instead of 2 for DECRQM queries of unsupported modes The status value 4 means "permanently reset", as opposed to 2, which means "reset". The former implies that there's no way to enable the mode because it's unsupported (but recognized). Note: this commit also fixes an unrelated typo in CHANGELOG.md.
2022-09-17 07:17:12 +01:00
unsigned status = decrqm(term, param);
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
char reply[32];
csi: reply with 4 instead of 2 for DECRQM queries of unsupported modes The status value 4 means "permanently reset", as opposed to 2, which means "reset". The former implies that there's no way to enable the mode because it's unsupported (but recognized). Note: this commit also fixes an unrelated typo in CHANGELOG.md.
2022-09-17 07:17:12 +01:00
size_t n = xsnprintf(reply, sizeof(reply), "\033[?%u;%u$y", param, status);
Add xsnprintf() and remove some unnecessary strlen(3) calls
2021-01-14 21:30:06 +00:00
term_to_slave(term, reply, n);
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
break;
}
default:
UNHANDLED();
break;
}
Don't use fancy Unicode quotes, stick to ASCII
2024-02-06 12:36:45 +01:00
break; /* private[0] == '?' && private[1] == '$' */
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
terminal: only support a single intermediate/private character
2019-07-10 15:03:16 +02:00
default:
vt: remove almost all abort() calls Replace with generic error log messages that simply says the ESC/CSI/OSC sequence is unhandled. This can mean either invalid or unimplemented, depending on the context.
2019-07-30 21:42:46 +02:00
UNHANDLED();
terminal: only support a single intermediate/private character
2019-07-10 15:03:16 +02:00
break;
wip: vt parsing: initial csi/osc dispatching
2019-06-15 22:22:44 +02:00
}
}
Reference in a new issue Copy permalink