587 lines
15 KiB
C
587 lines
15 KiB
C
#include "vterm_internal.h"
|
|
|
|
#include <stdio.h>
|
|
|
|
/**
|
|
* Structure used to store RGB triples without the additional metadata stored in
|
|
* VTermColor.
|
|
*/
|
|
typedef struct {
|
|
uint8_t red, green, blue;
|
|
} VTermRGB;
|
|
|
|
static const VTermRGB ansi_colors[] = {
|
|
/* R G B */
|
|
{0, 0, 0}, // black
|
|
{224, 0, 0}, // red
|
|
{0, 224, 0}, // green
|
|
{224, 224, 0}, // yellow
|
|
{0, 0, 224}, // blue
|
|
{224, 0, 224}, // magenta
|
|
{0, 224, 224}, // cyan
|
|
{224, 224, 224}, // white == light grey
|
|
|
|
// high intensity
|
|
{128, 128, 128}, // black
|
|
{255, 64, 64}, // red
|
|
{64, 255, 64}, // green
|
|
{255, 255, 64}, // yellow
|
|
{64, 64, 255}, // blue
|
|
{255, 64, 255}, // magenta
|
|
{64, 255, 255}, // cyan
|
|
{255, 255, 255}, // white for real
|
|
};
|
|
|
|
static int ramp6[] = {
|
|
0x00,
|
|
0x33,
|
|
0x66,
|
|
0x99,
|
|
0xCC,
|
|
0xFF,
|
|
};
|
|
|
|
static int ramp24[] = {
|
|
0x00,
|
|
0x0B,
|
|
0x16,
|
|
0x21,
|
|
0x2C,
|
|
0x37,
|
|
0x42,
|
|
0x4D,
|
|
0x58,
|
|
0x63,
|
|
0x6E,
|
|
0x79,
|
|
0x85,
|
|
0x90,
|
|
0x9B,
|
|
0xA6,
|
|
0xB1,
|
|
0xBC,
|
|
0xC7,
|
|
0xD2,
|
|
0xDD,
|
|
0xE8,
|
|
0xF3,
|
|
0xFF,
|
|
};
|
|
|
|
static void lookup_default_colour_ansi(long idx, VTermColor *col) {
|
|
if (idx >= 0 && idx < 16) {
|
|
vterm_color_rgb(
|
|
col,
|
|
ansi_colors[idx].red, ansi_colors[idx].green, ansi_colors[idx].blue);
|
|
}
|
|
}
|
|
|
|
static bool lookup_colour_ansi(const VTermState *state, long index, VTermColor *col) {
|
|
if (index >= 0 && index < 16) {
|
|
*col = state->colors[index];
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static bool lookup_colour_palette(const VTermState *state, long index, VTermColor *col) {
|
|
if (index >= 0 && index < 16) {
|
|
// Normal 8 colours or high intensity - parse as palette 0
|
|
return lookup_colour_ansi(state, index, col);
|
|
} else if (index >= 16 && index < 232) {
|
|
// 216-colour cube
|
|
index -= 16;
|
|
|
|
vterm_color_rgb(col, ramp6[index / 6 / 6 % 6], ramp6[index / 6 % 6], ramp6[index % 6]);
|
|
|
|
return true;
|
|
} else if (index >= 232 && index < 256) {
|
|
// 24 greyscales
|
|
index -= 232;
|
|
|
|
vterm_color_rgb(col, ramp24[index], ramp24[index], ramp24[index]);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
static int lookup_colour(const VTermState *state, int palette, const long args[], int argcount, VTermColor *col) {
|
|
switch (palette) {
|
|
case 2: // RGB mode - 3 args contain colour values directly
|
|
if (argcount < 3)
|
|
return argcount;
|
|
|
|
vterm_color_rgb(col, CSI_ARG(args[0]), CSI_ARG(args[1]), CSI_ARG(args[2]));
|
|
|
|
return 3;
|
|
|
|
case 5: // XTerm 256-colour mode
|
|
if (!argcount || CSI_ARG_IS_MISSING(args[0])) {
|
|
return argcount ? 1 : 0;
|
|
}
|
|
|
|
vterm_color_indexed(col, args[0]);
|
|
|
|
return argcount ? 1 : 0;
|
|
|
|
default:
|
|
DEBUG_LOG("Unrecognised colour palette %d\n", palette);
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// Some conveniences
|
|
|
|
static void setpenattr(VTermState *state, VTermAttr attr, VTermValueType type, VTermValue *val) {
|
|
#ifdef DEBUG
|
|
if (type != vterm_get_attr_type(attr)) {
|
|
DEBUG_LOG("Cannot set attr %d as it has type %d, not type %d\n", attr, vterm_get_attr_type(attr), type);
|
|
return;
|
|
}
|
|
#endif
|
|
if (state->callbacks && state->callbacks->setpenattr)
|
|
(*state->callbacks->setpenattr)(attr, val, state->cbdata);
|
|
}
|
|
|
|
static void setpenattr_bool(VTermState *state, VTermAttr attr, int boolean) {
|
|
VTermValue val = {.boolean = boolean};
|
|
setpenattr(state, attr, VTERM_VALUETYPE_BOOL, &val);
|
|
}
|
|
|
|
static void setpenattr_int(VTermState *state, VTermAttr attr, int number) {
|
|
VTermValue val = {.number = number};
|
|
setpenattr(state, attr, VTERM_VALUETYPE_INT, &val);
|
|
}
|
|
|
|
static void setpenattr_col(VTermState *state, VTermAttr attr, VTermColor color) {
|
|
VTermValue val = {.color = color};
|
|
setpenattr(state, attr, VTERM_VALUETYPE_COLOR, &val);
|
|
}
|
|
|
|
static void set_pen_col_ansi(VTermState *state, VTermAttr attr, long col) {
|
|
VTermColor *colp = (attr == VTERM_ATTR_BACKGROUND) ? &state->pen.bg : &state->pen.fg;
|
|
|
|
vterm_color_indexed(colp, col);
|
|
|
|
setpenattr_col(state, attr, *colp);
|
|
}
|
|
|
|
INTERNAL void vterm_state_newpen(VTermState *state) {
|
|
// 90% grey so that pure white is brighter
|
|
vterm_color_rgb(&state->default_fg, 240, 240, 240);
|
|
vterm_color_rgb(&state->default_bg, 0, 0, 0);
|
|
vterm_state_set_default_colors(state, &state->default_fg, &state->default_bg);
|
|
|
|
for (int col = 0; col < 16; col++)
|
|
lookup_default_colour_ansi(col, &state->colors[col]);
|
|
}
|
|
|
|
INTERNAL void vterm_state_resetpen(VTermState *state) {
|
|
state->pen.bold = 0;
|
|
setpenattr_bool(state, VTERM_ATTR_BOLD, 0);
|
|
state->pen.underline = 0;
|
|
setpenattr_int(state, VTERM_ATTR_UNDERLINE, 0);
|
|
state->pen.italic = 0;
|
|
setpenattr_bool(state, VTERM_ATTR_ITALIC, 0);
|
|
state->pen.blink = 0;
|
|
setpenattr_bool(state, VTERM_ATTR_BLINK, 0);
|
|
state->pen.reverse = 0;
|
|
setpenattr_bool(state, VTERM_ATTR_REVERSE, 0);
|
|
state->pen.strike = 0;
|
|
setpenattr_bool(state, VTERM_ATTR_STRIKE, 0);
|
|
state->pen.font = 0;
|
|
setpenattr_int(state, VTERM_ATTR_FONT, 0);
|
|
|
|
state->pen.fg = state->default_fg;
|
|
setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->default_fg);
|
|
state->pen.bg = state->default_bg;
|
|
setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->default_bg);
|
|
}
|
|
|
|
INTERNAL void vterm_state_savepen(VTermState *state, int save) {
|
|
if (save) {
|
|
state->saved.pen = state->pen;
|
|
} else {
|
|
state->pen = state->saved.pen;
|
|
|
|
setpenattr_bool(state, VTERM_ATTR_BOLD, state->pen.bold);
|
|
setpenattr_int(state, VTERM_ATTR_UNDERLINE, state->pen.underline);
|
|
setpenattr_bool(state, VTERM_ATTR_ITALIC, state->pen.italic);
|
|
setpenattr_bool(state, VTERM_ATTR_BLINK, state->pen.blink);
|
|
setpenattr_bool(state, VTERM_ATTR_REVERSE, state->pen.reverse);
|
|
setpenattr_bool(state, VTERM_ATTR_STRIKE, state->pen.strike);
|
|
setpenattr_int(state, VTERM_ATTR_FONT, state->pen.font);
|
|
setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg);
|
|
setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg);
|
|
}
|
|
}
|
|
|
|
int vterm_color_is_equal(const VTermColor *a, const VTermColor *b) {
|
|
/* First make sure that the two colours are of the same type (RGB/Indexed) */
|
|
if (a->type != b->type) {
|
|
return false;
|
|
}
|
|
|
|
/* Depending on the type inspect the corresponding members */
|
|
if (VTERM_COLOR_IS_INDEXED(a)) {
|
|
return a->indexed.idx == b->indexed.idx;
|
|
} else if (VTERM_COLOR_IS_RGB(a)) {
|
|
return (a->rgb.red == b->rgb.red) && (a->rgb.green == b->rgb.green) && (a->rgb.blue == b->rgb.blue);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
void vterm_state_get_default_colors(const VTermState *state, VTermColor *default_fg, VTermColor *default_bg) {
|
|
*default_fg = state->default_fg;
|
|
*default_bg = state->default_bg;
|
|
}
|
|
|
|
void vterm_state_get_palette_color(const VTermState *state, int index, VTermColor *col) {
|
|
lookup_colour_palette(state, index, col);
|
|
}
|
|
|
|
void vterm_state_set_default_colors(VTermState *state, const VTermColor *default_fg, const VTermColor *default_bg) {
|
|
/* Copy the given colors */
|
|
state->default_fg = *default_fg;
|
|
state->default_bg = *default_bg;
|
|
|
|
/* Make sure the correct type flags are set */
|
|
state->default_fg.type = (state->default_fg.type & ~VTERM_COLOR_DEFAULT_MASK) | VTERM_COLOR_DEFAULT_FG;
|
|
state->default_bg.type = (state->default_bg.type & ~VTERM_COLOR_DEFAULT_MASK) | VTERM_COLOR_DEFAULT_BG;
|
|
}
|
|
|
|
void vterm_state_set_palette_color(VTermState *state, int index, const VTermColor *col) {
|
|
if (index >= 0 && index < 16)
|
|
state->colors[index] = *col;
|
|
}
|
|
|
|
void vterm_state_convert_color_to_rgb(const VTermState *state, VTermColor *col) {
|
|
if (VTERM_COLOR_IS_INDEXED(col)) { /* Convert indexed colors to RGB */
|
|
lookup_colour_palette(state, col->indexed.idx, col);
|
|
}
|
|
col->type &= VTERM_COLOR_TYPE_MASK; /* Reset any metadata but the type */
|
|
}
|
|
|
|
void vterm_state_set_bold_highbright(VTermState *state, int bold_is_highbright) {
|
|
state->bold_is_highbright = bold_is_highbright;
|
|
}
|
|
|
|
INTERNAL void vterm_state_setpen(VTermState *state, const long args[], int argcount) {
|
|
// SGR - ECMA-48 8.3.117
|
|
|
|
int argi = 0;
|
|
int value;
|
|
|
|
while (argi < argcount) {
|
|
// This logic is easier to do 'done' backwards; set it true, and make it
|
|
// false again in the 'default' case
|
|
int done = 1;
|
|
|
|
long arg;
|
|
switch (arg = CSI_ARG(args[argi])) {
|
|
case CSI_ARG_MISSING:
|
|
case 0: // Reset
|
|
vterm_state_resetpen(state);
|
|
break;
|
|
|
|
case 1: { // Bold on
|
|
const VTermColor *fg = &state->pen.fg;
|
|
state->pen.bold = 1;
|
|
setpenattr_bool(state, VTERM_ATTR_BOLD, 1);
|
|
if (!VTERM_COLOR_IS_DEFAULT_FG(fg) && VTERM_COLOR_IS_INDEXED(fg) && fg->indexed.idx < 8 && state->bold_is_highbright)
|
|
set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, fg->indexed.idx + (state->pen.bold ? 8 : 0));
|
|
break;
|
|
}
|
|
|
|
case 3: // Italic on
|
|
state->pen.italic = 1;
|
|
setpenattr_bool(state, VTERM_ATTR_ITALIC, 1);
|
|
break;
|
|
|
|
case 4: // Underline
|
|
state->pen.underline = VTERM_UNDERLINE_SINGLE;
|
|
if (CSI_ARG_HAS_MORE(args[argi])) {
|
|
argi++;
|
|
switch (CSI_ARG(args[argi])) {
|
|
case 0:
|
|
state->pen.underline = 0;
|
|
break;
|
|
case 1:
|
|
state->pen.underline = VTERM_UNDERLINE_SINGLE;
|
|
break;
|
|
case 2:
|
|
state->pen.underline = VTERM_UNDERLINE_DOUBLE;
|
|
break;
|
|
case 3:
|
|
state->pen.underline = VTERM_UNDERLINE_CURLY;
|
|
break;
|
|
}
|
|
}
|
|
setpenattr_int(state, VTERM_ATTR_UNDERLINE, state->pen.underline);
|
|
break;
|
|
|
|
case 5: // Blink
|
|
state->pen.blink = 1;
|
|
setpenattr_bool(state, VTERM_ATTR_BLINK, 1);
|
|
break;
|
|
|
|
case 7: // Reverse on
|
|
state->pen.reverse = 1;
|
|
setpenattr_bool(state, VTERM_ATTR_REVERSE, 1);
|
|
break;
|
|
|
|
case 9: // Strikethrough on
|
|
state->pen.strike = 1;
|
|
setpenattr_bool(state, VTERM_ATTR_STRIKE, 1);
|
|
break;
|
|
|
|
case 10:
|
|
case 11:
|
|
case 12:
|
|
case 13:
|
|
case 14:
|
|
case 15:
|
|
case 16:
|
|
case 17:
|
|
case 18:
|
|
case 19: // Select font
|
|
state->pen.font = CSI_ARG(args[argi]) - 10;
|
|
setpenattr_int(state, VTERM_ATTR_FONT, state->pen.font);
|
|
break;
|
|
|
|
case 21: // Underline double
|
|
state->pen.underline = VTERM_UNDERLINE_DOUBLE;
|
|
setpenattr_int(state, VTERM_ATTR_UNDERLINE, state->pen.underline);
|
|
break;
|
|
|
|
case 22: // Bold off
|
|
state->pen.bold = 0;
|
|
setpenattr_bool(state, VTERM_ATTR_BOLD, 0);
|
|
break;
|
|
|
|
case 23: // Italic and Gothic (currently unsupported) off
|
|
state->pen.italic = 0;
|
|
setpenattr_bool(state, VTERM_ATTR_ITALIC, 0);
|
|
break;
|
|
|
|
case 24: // Underline off
|
|
state->pen.underline = 0;
|
|
setpenattr_int(state, VTERM_ATTR_UNDERLINE, 0);
|
|
break;
|
|
|
|
case 25: // Blink off
|
|
state->pen.blink = 0;
|
|
setpenattr_bool(state, VTERM_ATTR_BLINK, 0);
|
|
break;
|
|
|
|
case 27: // Reverse off
|
|
state->pen.reverse = 0;
|
|
setpenattr_bool(state, VTERM_ATTR_REVERSE, 0);
|
|
break;
|
|
|
|
case 29: // Strikethrough off
|
|
state->pen.strike = 0;
|
|
setpenattr_bool(state, VTERM_ATTR_STRIKE, 0);
|
|
break;
|
|
|
|
case 30:
|
|
case 31:
|
|
case 32:
|
|
case 33:
|
|
case 34:
|
|
case 35:
|
|
case 36:
|
|
case 37: // Foreground colour palette
|
|
value = CSI_ARG(args[argi]) - 30;
|
|
if (state->pen.bold && state->bold_is_highbright)
|
|
value += 8;
|
|
set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, value);
|
|
break;
|
|
|
|
case 38: // Foreground colour alternative palette
|
|
if (argcount - argi < 1)
|
|
return;
|
|
argi += 1 + lookup_colour(state, CSI_ARG(args[argi + 1]), args + argi + 2, argcount - argi - 2, &state->pen.fg);
|
|
setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg);
|
|
break;
|
|
|
|
case 39: // Foreground colour default
|
|
state->pen.fg = state->default_fg;
|
|
setpenattr_col(state, VTERM_ATTR_FOREGROUND, state->pen.fg);
|
|
break;
|
|
|
|
case 40:
|
|
case 41:
|
|
case 42:
|
|
case 43:
|
|
case 44:
|
|
case 45:
|
|
case 46:
|
|
case 47: // Background colour palette
|
|
value = CSI_ARG(args[argi]) - 40;
|
|
set_pen_col_ansi(state, VTERM_ATTR_BACKGROUND, value);
|
|
break;
|
|
|
|
case 48: // Background colour alternative palette
|
|
if (argcount - argi < 1)
|
|
return;
|
|
argi += 1 + lookup_colour(state, CSI_ARG(args[argi + 1]), args + argi + 2, argcount - argi - 2, &state->pen.bg);
|
|
setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg);
|
|
break;
|
|
|
|
case 49: // Default background
|
|
state->pen.bg = state->default_bg;
|
|
setpenattr_col(state, VTERM_ATTR_BACKGROUND, state->pen.bg);
|
|
break;
|
|
|
|
case 90:
|
|
case 91:
|
|
case 92:
|
|
case 93:
|
|
case 94:
|
|
case 95:
|
|
case 96:
|
|
case 97: // Foreground colour high-intensity palette
|
|
value = CSI_ARG(args[argi]) - 90 + 8;
|
|
set_pen_col_ansi(state, VTERM_ATTR_FOREGROUND, value);
|
|
break;
|
|
|
|
case 100:
|
|
case 101:
|
|
case 102:
|
|
case 103:
|
|
case 104:
|
|
case 105:
|
|
case 106:
|
|
case 107: // Background colour high-intensity palette
|
|
value = CSI_ARG(args[argi]) - 100 + 8;
|
|
set_pen_col_ansi(state, VTERM_ATTR_BACKGROUND, value);
|
|
break;
|
|
|
|
default:
|
|
done = 0;
|
|
break;
|
|
}
|
|
|
|
if (!done)
|
|
DEBUG_LOG("libvterm: Unhandled CSI SGR %lu\n", arg);
|
|
|
|
while (CSI_ARG_HAS_MORE(args[argi++]))
|
|
;
|
|
}
|
|
}
|
|
|
|
static int vterm_state_getpen_color(const VTermColor *col, int argi, long args[], int fg) {
|
|
/* Do nothing if the given color is the default color */
|
|
if ((fg && VTERM_COLOR_IS_DEFAULT_FG(col)) ||
|
|
(!fg && VTERM_COLOR_IS_DEFAULT_BG(col))) {
|
|
return argi;
|
|
}
|
|
|
|
/* Decide whether to send an indexed color or an RGB color */
|
|
if (VTERM_COLOR_IS_INDEXED(col)) {
|
|
const uint8_t idx = col->indexed.idx;
|
|
if (idx < 8) {
|
|
args[argi++] = (idx + (fg ? 30 : 40));
|
|
} else if (idx < 16) {
|
|
args[argi++] = (idx - 8 + (fg ? 90 : 100));
|
|
} else {
|
|
args[argi++] = CSI_ARG_FLAG_MORE | (fg ? 38 : 48);
|
|
args[argi++] = CSI_ARG_FLAG_MORE | 5;
|
|
args[argi++] = idx;
|
|
}
|
|
} else if (VTERM_COLOR_IS_RGB(col)) {
|
|
args[argi++] = CSI_ARG_FLAG_MORE | (fg ? 38 : 48);
|
|
args[argi++] = CSI_ARG_FLAG_MORE | 2;
|
|
args[argi++] = CSI_ARG_FLAG_MORE | col->rgb.red;
|
|
args[argi++] = CSI_ARG_FLAG_MORE | col->rgb.green;
|
|
args[argi++] = col->rgb.blue;
|
|
}
|
|
return argi;
|
|
}
|
|
|
|
INTERNAL int vterm_state_getpen(VTermState *state, long args[], int argcount) {
|
|
int argi = 0;
|
|
|
|
if (state->pen.bold)
|
|
args[argi++] = 1;
|
|
|
|
if (state->pen.italic)
|
|
args[argi++] = 3;
|
|
|
|
if (state->pen.underline == VTERM_UNDERLINE_SINGLE)
|
|
args[argi++] = 4;
|
|
if (state->pen.underline == VTERM_UNDERLINE_CURLY)
|
|
args[argi++] = 4 | CSI_ARG_FLAG_MORE, args[argi++] = 3;
|
|
|
|
if (state->pen.blink)
|
|
args[argi++] = 5;
|
|
|
|
if (state->pen.reverse)
|
|
args[argi++] = 7;
|
|
|
|
if (state->pen.strike)
|
|
args[argi++] = 9;
|
|
|
|
if (state->pen.font)
|
|
args[argi++] = 10 + state->pen.font;
|
|
|
|
if (state->pen.underline == VTERM_UNDERLINE_DOUBLE)
|
|
args[argi++] = 21;
|
|
|
|
argi = vterm_state_getpen_color(&state->pen.fg, argi, args, true);
|
|
|
|
argi = vterm_state_getpen_color(&state->pen.bg, argi, args, false);
|
|
|
|
return argi;
|
|
}
|
|
|
|
int vterm_state_get_penattr(const VTermState *state, VTermAttr attr, VTermValue *val) {
|
|
switch (attr) {
|
|
case VTERM_ATTR_BOLD:
|
|
val->boolean = state->pen.bold;
|
|
return 1;
|
|
|
|
case VTERM_ATTR_UNDERLINE:
|
|
val->number = state->pen.underline;
|
|
return 1;
|
|
|
|
case VTERM_ATTR_ITALIC:
|
|
val->boolean = state->pen.italic;
|
|
return 1;
|
|
|
|
case VTERM_ATTR_BLINK:
|
|
val->boolean = state->pen.blink;
|
|
return 1;
|
|
|
|
case VTERM_ATTR_REVERSE:
|
|
val->boolean = state->pen.reverse;
|
|
return 1;
|
|
|
|
case VTERM_ATTR_STRIKE:
|
|
val->boolean = state->pen.strike;
|
|
return 1;
|
|
|
|
case VTERM_ATTR_FONT:
|
|
val->number = state->pen.font;
|
|
return 1;
|
|
|
|
case VTERM_ATTR_FOREGROUND:
|
|
val->color = state->pen.fg;
|
|
return 1;
|
|
|
|
case VTERM_ATTR_BACKGROUND:
|
|
val->color = state->pen.bg;
|
|
return 1;
|
|
|
|
case VTERM_N_ATTRS:
|
|
return 0;
|
|
}
|
|
|
|
return 0;
|
|
}
|