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

1683 lines
55 KiB
C
Raw 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: xtsave/xtrestore: implement \E[?12s and \E[?12r I.e. save/restore cursor-blink state.
2020-08-18 07:00:26 +02:00
#include <errno.h>
wip: vt parsing
2019-06-17 18:57:12 +02:00
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"
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)
{
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
memset(&term->vt.attrs, 0, sizeof(term->vt.attrs));
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.fg = term->colors.fg;
term->vt.attrs.bg = term->colors.bg;
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;
case 4: term->vt.attrs.underline = true; 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: SGR 21 is “double underline”, not “disable bold” (according to ECMA-48)
2020-12-14 19:10:30 +01:00
case 21: break; /* double-underline, not implemented */
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;
case 24: term->vt.attrs.underline = false; 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:
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.have_fg = 1;
term: rename colors256 -> table
2019-08-21 18:50:24 +02:00
term->vt.attrs.fg = term->colors.table[param - 30];
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
break;
case 38: {
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: color index is an 8-bit unsigned value This fixes an issue where a large 8-bit value was signed extended into a large 64-bit value.
2019-07-18 14:25:15 +02:00
uint8_t idx = term->vt.params.v[i + 2].value;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.have_fg = 1;
term: rename colors256 -> table
2019-08-21 18:50:24 +02:00
term->vt.attrs.fg = term->colors.table[idx];
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;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.have_fg = 1;
term->vt.attrs.fg = 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)
{
const struct vt_param *param = &term->vt.params.v[i];
uint8_t idx = param->sub.value[1];
term->vt.attrs.have_fg = 1;
term->vt.attrs.fg = term->colors.table[idx];
}
/*
* 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];
term->vt.attrs.have_fg = 1;
term->vt.attrs.fg = 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 */
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
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);
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
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:
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.have_fg = 0;
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:
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.have_bg = 1;
term: rename colors256 -> table
2019-08-21 18:50:24 +02:00
term->vt.attrs.bg = term->colors.table[param - 40];
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
break;
case 48: {
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: 48;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: color index is an 8-bit unsigned value This fixes an issue where a large 8-bit value was signed extended into a large 64-bit value.
2019-07-18 14:25:15 +02:00
uint8_t idx = term->vt.params.v[i + 2].value;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.have_bg = 1;
term: rename colors256 -> table
2019-08-21 18:50:24 +02:00
term->vt.attrs.bg = term->colors.table[idx];
vt: initial implementation of alt screen + 256 colors
2019-06-23 15:00:27 +02:00
i += 2;
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
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: 48;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 &&
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 + 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;
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.have_bg = 1;
term->vt.attrs.bg = 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: 48: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)
{
const struct vt_param *param = &term->vt.params.v[i];
uint8_t idx = param->sub.value[1];
term->vt.attrs.have_bg = 1;
term->vt.attrs.bg = term->colors.table[idx];
}
/*
* RGB: 48:2:<color-space>:r:g:b[:ignored:tolerance:tolerance-color-space]
* RGB: 48: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];
term->vt.attrs.have_bg = 1;
term->vt.attrs.bg = 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: 48:1 */
/* CMY: 48:3:<color-space>:c:m:y[:tolerance:tolerance-color-space] */
/* CMYK: 48:4:<color-space>:c:m:y:k[:tolerance:tolerance-color-space] */
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
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);
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
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:
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.have_bg = 0;
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
/* 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:
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.have_fg = 1;
term: rename colors256 -> table
2019-08-21 18:50:24 +02:00
term->vt.attrs.fg = term->colors.table[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:
cell: pack more efficiently and store glyph as a wchar The 'attributes' struct is now 8 bytes and naturally packed (used to be 9 bytes, artificially packed). 'cell' struct is now 12 bytes, naturally packed (used to be 13 bytes, artificially packed). Furthermore, the glyph is stored as a wchar instead of a char*. This makes it easier (faster) to do glyph lookup when rendering.
2019-08-02 18:19:07 +02:00
term->vt.attrs.have_bg = 1;
term: rename colors256 -> table
2019-08-21 18:50:24 +02:00
term->vt.attrs.bg = term->colors.table[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 3:
csi: add DEC names to a couple of DECSET modes
2020-08-16 16:25:52 +02:00
/* DECCOLM */
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
if (enable)
LOG_WARN("unimplemented: 132 column mode (DECCOLM)");
term_erase(
term,
&(struct coord){0, 0},
&(struct coord){term->cols - 1, term->rows - 1});
term_cursor_home(term);
break;
case 4:
/* DECSCLM - Smooth scroll */
if (enable)
LOG_WARN("unimplemented: Smooth (Slow) Scroll (DECSCLM)");
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;
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;
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);
csi: break out decset/decrst
2020-08-16 16:20:47 +02:00
term_erase(
term,
&(struct coord){0, 0},
&(struct coord){term->cols - 1, term->rows - 1});
}
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: break out decset/decrst
2020-08-16 16:20:47 +02:00
term_damage_all(term);
}
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;
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 new private mode that makes the Escape key emit "\E[27;1;27~" This mode can be set by client programs with the DECSET, DECRST, XTSAVE and XTRESTORE sequences by using 27127 as the parameter. The sequence "\E[27;1;27~" is encoded in the same way as is done by xterm's "modifyOtherKeys" mode. Even though xterm itself never emits such a sequence for the Escape key, many programs already have support for parsing this style of key sequence.
2020-11-29 04:04:57 +00:00
case 27127:
term->modify_escape_key = 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);
else
term_ime_disable(term);
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: 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
static bool
decrqm(const struct terminal *term, unsigned param, bool *enabled)
{
switch (param) {
case 1: *enabled = term->cursor_keys_mode == CURSOR_KEYS_APPLICATION; return true;
case 3: *enabled = false; return true;
case 4: *enabled = false; return true;
case 5: *enabled = term->reverse; return true;
case 6: *enabled = term->origin; return true;
case 7: *enabled = term->auto_margin; return true;
case 9: *enabled = false; /* term->mouse_tracking == MOUSE_X10; */ return true;
case 12: *enabled = term->cursor_blink.decset; return true;
case 25: *enabled = !term->hide_cursor; return true;
case 45: *enabled = term->reverse_wrap; return true;
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: *enabled = !term->sixel.scrolling; return true;
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
case 1000: *enabled = term->mouse_tracking == MOUSE_CLICK; return true;
case 1001: *enabled = false; return true;
case 1002: *enabled = term->mouse_tracking == MOUSE_DRAG; return true;
case 1003: *enabled = term->mouse_tracking == MOUSE_MOTION; return true;
case 1004: *enabled = term->focus_events; return true;
case 1005: *enabled = false; /* term->mouse_reporting == MOUSE_UTF8; */ return true;
case 1006: *enabled = term->mouse_reporting == MOUSE_SGR; return true;
case 1007: *enabled = term->alt_scrolling; return true;
case 1015: *enabled = term->mouse_reporting == MOUSE_URXVT; return true;
case 1034: *enabled = term->meta.eight_bit; return true;
case 1035: *enabled = term->num_lock_modifier; return true;
case 1036: *enabled = term->meta.esc_prefix; return true;
case 1042: *enabled = term->bell_action_enabled; return true;
csi: add 47+1047 (alt screen) to DECRQM
2021-02-09 20:02:29 +01:00
case 47: /* FALLTHROUGH */
case 1047: /* FALLTHROUGH */
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
case 1049: *enabled = term->grid == &term->alt; return true;
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 1079: *enabled = term->sixel.use_private_palette; return true;
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
case 2004: *enabled = term->bracketed_paste; return true;
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: *enabled = term->render.app_sync_updates.enabled; return true;
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: *enabled = term->sixel.cursor_right_of_graphics; return true;
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
case 27127: *enabled = term->modify_escape_key; return true;
case 737769: *enabled = term_ime_is_enabled(term); return true;
}
return false;
}
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 3: break;
case 4: break;
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: 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;
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;
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 new private mode that makes the Escape key emit "\E[27;1;27~" This mode can be set by client programs with the DECSET, DECRST, XTSAVE and XTRESTORE sequences by using 27127 as the parameter. The sequence "\E[27;1;27~" is encoded in the same way as is done by xterm's "modifyOtherKeys" mode. Even though xterm itself never emits such a sequence for the Escape key, many programs already have support for parsing this style of key sequence.
2020-11-29 04:04:57 +00:00
case 27127: term->xtsave.modify_escape_key = term->modify_escape_key; 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 3: return;
case 4: return;
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: 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;
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;
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 new private mode that makes the Escape key emit "\E[27;1;27~" This mode can be set by client programs with the DECSET, DECRST, XTSAVE and XTRESTORE sequences by using 27127 as the parameter. The sequence "\E[27;1;27~" is encoded in the same way as is done by xterm's "modifyOtherKeys" mode. Even though xterm itself never emits such a sequence for the Escape key, many programs already have support for parsing this style of key sequence.
2020-11-29 04:04:57 +00:00
case 27127: enable = term->xtsave.modify_escape_key; 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);
}
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
const int width = wcwidth(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_print(term, term->vt.last_printed, width);
}
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
*/
csi: various, minor code/formatting improvements
2021-08-30 07:40:03 +01:00
static const char reply[] = "\033[?62;4;22c";
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;
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, term->grid->cursor.point.row, 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) {
case 0:
/* From cursor to end of screen */
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,
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,
wip: grid is now represented as a grid, not a linear array The grid is now represented with an array of row *pointers*. Each row contains an array of cells (the row's columns). The main point of having row pointers is we can now move rows around almost for free. This is useful when scrolling with scroll margins for example, where we previously had to copy the lines in the margins. Now it's just a matter of swapping two pointers.
2019-07-08 13:57:31 +02:00
&(struct coord){term->cols - 1, term->rows - 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;
case 1:
/* From start of screen to cursor */
grid: move 'cursor' state from terminal to grid This way, the 'normal' and 'alt' grids have their own cursor state, and we don't need to switch between them.
2020-04-16 18:51:14 +02:00
term_erase(term, &(struct coord){0, 0}, &term->grid->cursor.point);
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
case 2:
/* Erase entire screen */
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,
&(struct coord){0, 0},
&(struct coord){term->cols - 1, term->rows - 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) {
case 0:
/* From cursor to end of line */
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,
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,
&(struct coord){term->cols - 1, term->grid->cursor.point.row});
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
case 1:
/* From start of line to cursor */
wip: grid is now represented as a grid, not a linear array The grid is now represented with an array of row *pointers*. Each row contains an array of cells (the row's columns). The main point of having row pointers is we can now move rows around almost for free. This is useful when scrolling with scroll margins for example, where we previously had to copy the lines in the margins. Now it's just a matter of swapping two pointers.
2019-07-08 13:57:31 +02:00
term_erase(
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, &(struct coord){0, term->grid->cursor.point.row}, &term->grid->cursor.point);
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +02:00
break;
case 2:
/* Entire line */
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,
grid: move 'cursor' state from terminal to grid This way, the 'normal' and 'alt' grids have their own cursor state, and we don't need to switch between them.
2020-04-16 18:51:14 +02:00
&(struct coord){0, term->grid->cursor.point.row},
&(struct coord){term->cols - 1, term->grid->cursor.point.row});
term->grid->cursor.lcf = false;
wip: initial input handling
2019-06-19 10:04:47 +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;
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;
}
scrolling region: wip
2019-06-23 21:12:32 +02:00
case 'L': {
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;
}
case 'M': {
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 */
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,
grid: move 'cursor' state from terminal to grid This way, the 'normal' and 'alt' grids have their own cursor state, and we don't need to switch between them.
2020-04-16 18:51:14 +02:00
&(struct coord){term->grid->cursor.point.col + remaining, term->grid->cursor.point.row},
&(struct coord){term->cols - 1, term->grid->cursor.point.row});
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) */
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,
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,
&(struct coord){term->grid->cursor.point.col + count - 1, term->grid->cursor.point.row});
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
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,
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,
&(struct coord){term->grid->cursor.point.col + count - 1, term->grid->cursor.point.row});
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: 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
/* Set mode */
switch (vt_param_get(term, 0, 0)) {
case 2: /* Keyboard Action Mode - AM */
LOG_WARN("unimplemented: keyboard action mode (AM)");
break;
case 4: /* Insert Mode - IRM */
term->insert_mode = true;
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;
case 12: /* Send/receive Mode - SRM */
LOG_WARN("unimplemented: send/receive mode (SRM)");
break;
case 20: /* Automatic Newline Mode - LNM */
term: rename term_formfeed() -> term_carriage_return()
2020-07-14 09:29:10 +02:00
/* TODO: would be easy to implemented; when active
* term_linefeed() would _also_ do a
* term_carriage_return() */
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
LOG_WARN("unimplemented: automatic newline mode (LNM)");
break;
}
vt: implement (untested!) insert mode \E4l is not horizontal index, but disable INSERT mode
2019-07-03 21:16:41 +02:00
break;
csi: add untested implementation of "horizontal index"
2019-07-03 14:47:01 +02:00
vt: implement (untested!) insert mode \E4l is not horizontal index, but disable INSERT mode
2019-07-03 21:16:41 +02:00
case 'l':
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
/* Reset mode */
switch (vt_param_get(term, 0, 0)) {
case 4: /* Insert Mode - IRM */
term->insert_mode = false;
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;
case 2: /* Keyboard Action Mode - AM */
case 12: /* Send/receive Mode - SRM */
case 20: /* Automatic Newline Mode - LNM */
break;
}
csi: add untested implementation of "horizontal index"
2019-07-03 14:47:01 +02:00
break;
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;
case 20: LOG_WARN("unimplemented: report icon label"); break;
case 21: LOG_WARN("unimplemented: report window title"); break;
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];
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[4;%d;%dt",
csi: CSI Ps ; Ps ; Ps t: report logical pixels
2020-04-18 23:20:09 +02:00
height / term->scale, width / term->scale);
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: 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
it->item->dim.px_scaled.height,
it->item->dim.px_scaled.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];
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[6;%d;%dt",
csi: CSI Ps ; Ps ; Ps t: report logical pixels
2020-04-18 23:20:09 +02:00
term->cell_height / term->scale,
term->cell_width / term->scale);
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];
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[9;%d;%dt",
csi: CSI Ps ; Ps ; Ps t: report logical pixels
2020-04-18 23:20:09 +02:00
it->item->dim.px_real.height / term->cell_height / term->scale,
csi: fix typo - the '(' was in the wrong place
2020-04-19 14:52:14 +02:00
it->item->dim.px_real.width / term->cell_width / term->scale);
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;
}
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': {
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: 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:
LOG_WARN("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 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
}
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;
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 = term->conf->cursor.blink;
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 */
term->cursor_style = 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;
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
}
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
*/
bool enabled;
unsigned value;
if (decrqm(term, param, &enabled))
value = enabled ? 1 : 2;
else
value = 0;
char reply[32];
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[?%u;%u$y", param, value);
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;
}
break; /* private[0] == ‘?’ && private[1] == ‘$’ */
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