Make mark colors respect color layers
Some checks are pending
CI / Linux (python=3.14 cc=clang sanitize=1) (push) Waiting to run
CI / Linux (python=3.12 cc=gcc sanitize=0) (push) Waiting to run
CI / Linux (python=3.13 cc=gcc sanitize=1) (push) Waiting to run
CI / Linux package (push) Waiting to run
CI / Bundle test (macos-latest) (push) Waiting to run
CI / Bundle test (ubuntu-latest) (push) Waiting to run
CI / macOS Brew (push) Waiting to run
CI / Test ./dev.sh and benchmark (push) Waiting to run
CodeQL / CodeQL-Build (actions, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, macos-latest) (push) Waiting to run
CodeQL / CodeQL-Build (c, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (go, ubuntu-latest) (push) Waiting to run
CodeQL / CodeQL-Build (python, ubuntu-latest) (push) Waiting to run
Depscan / Scan dependencies for vulnerabilities (push) Waiting to run

Mark colors are now stored per color layer and for the colors set by the
program, like the other colors, instead of in a single array that every
change overwrote. So set-colors without --configured no longer changes the
configured mark colors, window and session layer mark colors survive
changes to the global colors, resetting a layer, the color stack and full
reset restore the correct mark colors, --copy-colors copies them and
get-colors reports the mark colors of the window.
This commit is contained in:
Kovid Goyal 2026-10-29 08:57:18 +05:30
parent 862c8657be
commit bc46f1bafc
No known key found for this signature in database
GPG key ID: 06BC317B515ACE7C
3 changed files with 160 additions and 30 deletions

View file

@ -144,7 +144,7 @@ set_configured_colors(ColorProfile *self, PyObject *opts) {
static bool
set_mark_colors(ColorProfile *self, PyObject *opts) {
char fgattr[] = "mark?_foreground", bgattr[] = "mark?_background";
#define n(i, attr, which) \
#define n(attr, which) \
{ \
attr[4] = '1' + i; \
RAII_PyObject(t, PyObject_GetAttrString(opts, attr)); \
@ -153,16 +153,13 @@ set_mark_colors(ColorProfile *self, PyObject *opts) {
PyErr_SetString(PyExc_TypeError, "mark color is not Color object"); \
return false; \
} \
Color *c = (Color *)t; \
self->which[i] = c->color.rgb; \
self->global_layer.mark_colors.which[i].rgb = ((Color *)t)->color.rgb; \
self->global_layer.mark_colors.which[i].type = COLOR_IS_RGB; \
}
for (unsigned i = 0; i < MARK_MASK; i++) {
n(fgattr, fg);
n(bgattr, bg);
}
#define m(i) \
n(i, fgattr, mark_foregrounds); \
n(i, bgattr, mark_backgrounds);
m(0);
m(1);
m(2);
#undef m
#undef n
return true;
}
@ -338,6 +335,28 @@ palette_generation_is_dynamic(PyObject *opts, bool *semantic) {
}
// }}}
// The current mark colors are the colors set by the program, if any, otherwise
// the colors from the topmost color layer that has them
static void
resolve_mark_colors(ColorProfile *self) {
const MarkColors *layers[] = {
&self->overridden_mark_colors, &self->session_layer.mark_colors, &self->window_layer.mark_colors, &self->global_layer.mark_colors};
#define S(which, dest) \
self->dest[i] = 0; \
for (unsigned l = 0; l < arraysz(layers); l++) { \
if (layers[l]->which[i].type != COLOR_NOT_SET) { \
self->dest[i] = layers[l]->which[i].rgb; \
break; \
} \
}
for (unsigned i = 0; i < MARK_MASK; i++) {
S(bg, mark_backgrounds);
S(fg, mark_foregrounds);
}
#undef S
self->dirty = true;
}
static void
fill_generated_colors(color_type fg, color_type bg, color_type *color_table, bool dynamic, bool semantic, const ColorTableMask only) {
if (dynamic) generate_256_palette(fg, bg, color_table, semantic, only);
@ -402,7 +421,7 @@ colorprofile_resolve(ColorProfile *self, PyObject *opts, bool configured_changed
semantic,
self->overridden_color_table_mask);
}
self->dirty = true;
resolve_mark_colors(self);
}
static bool
@ -479,7 +498,8 @@ copy_color_profile(ColorProfile *dest, ColorProfile *src) {
memcpy(&dest->overridden, &src->overridden, sizeof(dest->overridden));
memcpy(dest->overriden_transparent_colors, src->overriden_transparent_colors, sizeof(dest->overriden_transparent_colors));
memcpy(dest->configured_transparent_colors, src->configured_transparent_colors, sizeof(dest->configured_transparent_colors));
dest->dirty = true;
dest->overridden_mark_colors = src->overridden_mark_colors;
resolve_mark_colors(dest);
}
static ColorLayer *
@ -532,18 +552,28 @@ patch_color_table(const char *key, PyObject *profiles, PyObject *spec, size_t wh
}
}
#define patch_mark_color(key, profiles, spec, array, i) \
{ \
PyObject *v = PyDict_GetItemString(spec, key); \
if (v && PyLong_Check(v)) { \
color_type color = PyLong_AsUnsignedLong(v); \
for (Py_ssize_t j = 0; j < PyTuple_GET_SIZE(profiles); j++) { \
ColorProfile *self = (ColorProfile *)PyTuple_GET_ITEM(profiles, j); \
self->array[i] = color; \
self->dirty = true; \
} \
} \
static void
patch_mark_color(const char *key, PyObject *profiles, PyObject *spec, size_t which, bool foreground, ColorLayerType layer, bool clear_upper_layers) {
#define mc(m) (foreground ? (m).fg : (m).bg)[which]
PyObject *v = PyDict_GetItemString(spec, key);
if (v && PyLong_Check(v)) {
const DynamicColor color = {.rgb = PyLong_AsUnsignedLong(v), .type = COLOR_IS_RGB};
for (Py_ssize_t j = 0; j < PyTuple_GET_SIZE(profiles); j++) {
ColorProfile *self = (ColorProfile *)PyTuple_GET_ITEM(profiles, j);
ColorLayer *l = color_layer(self, layer);
if (l) {
mc(l->mark_colors) = color;
if (clear_upper_layers) {
ColorLayer *upper[3];
color_layers_above(self, layer, upper);
for (ColorLayer **u = upper; *u; u++) mc((*u)->mark_colors).val = 0;
mc(self->overridden_mark_colors).val = 0;
}
} else mc(self->overridden_mark_colors) = color;
}
}
#undef mc
}
static PyObject *
@ -573,13 +603,11 @@ patch_color_profiles(PyObject *module UNUSED, PyObject *args) {
snprintf(key, sizeof(key) - 1, "color%zu", i);
patch_color_table(key, profiles, spec, i, layer, clear_upper_layers);
}
for (size_t i = 1; i <= MARK_MASK; i++) {
#define S(which, i) \
snprintf(key, sizeof(key) - 1, "mark%zu_" #which, i); \
patch_mark_color(key, profiles, spec, mark_##which##s, i - 1)
S(background, i);
S(foreground, i);
#undef S
for (size_t i = 0; i < MARK_MASK; i++) {
snprintf(key, sizeof(key) - 1, "mark%zu_background", i + 1);
patch_mark_color(key, profiles, spec, i, false, layer, clear_upper_layers);
snprintf(key, sizeof(key) - 1, "mark%zu_foreground", i + 1);
patch_mark_color(key, profiles, spec, i, true, layer, clear_upper_layers);
}
#define SI(profile_name) \
DynamicColor color; \
@ -773,6 +801,19 @@ as_dict(ColorProfile *self, PyObject *args UNUSED) {
D(highlight_fg, selection_foreground);
D(highlight_bg, selection_background);
D(visual_bell_color, visual_bell_color);
#undef D
char key[32];
#define D(which, dest, name) \
if (self->overridden_mark_colors.which[i].type != COLOR_NOT_SET || self->window_layer.mark_colors.which[i].type != COLOR_NOT_SET || \
self->session_layer.mark_colors.which[i].type != COLOR_NOT_SET) { \
snprintf(key, sizeof(key), "mark%u_" name, i + 1); \
RAII_PyObject(val, PyLong_FromUnsignedLong(self->dest[i])); \
if (!val || PyDict_SetItemString(ans, key, val) != 0) return NULL; \
}
for (unsigned i = 0; i < MARK_MASK; i++) {
D(bg, mark_backgrounds, "background");
D(fg, mark_foregrounds, "foreground");
}
RAII_PyObject(transparent_background_colors, PyList_New(0));
if (!transparent_background_colors) return NULL;
for (size_t i = 0; i < arraysz(self->overriden_transparent_colors); i++) {
@ -904,6 +945,7 @@ push_onto_color_stack_at(ColorProfile *self, unsigned int i) {
memcpy(self->color_stack[i].transparent_colors, self->overriden_transparent_colors, sizeof(self->overriden_transparent_colors));
memcpy(self->color_stack[i].color_table, self->color_table, sizeof(self->color_stack->color_table));
memcpy(self->color_stack[i].color_table_mask, self->overridden_color_table_mask, sizeof(self->color_stack->color_table_mask));
self->color_stack[i].mark_colors = self->overridden_mark_colors;
}
static void
@ -912,6 +954,7 @@ copy_from_color_stack_at(ColorProfile *self, unsigned int i) {
memcpy(self->color_table, self->color_stack[i].color_table, sizeof(self->color_table));
memcpy(self->overridden_color_table_mask, self->color_stack[i].color_table_mask, sizeof(self->overridden_color_table_mask));
memcpy(self->overriden_transparent_colors, self->color_stack[i].transparent_colors, sizeof(self->overriden_transparent_colors));
self->overridden_mark_colors = self->color_stack[i].mark_colors;
colorprofile_resolve(self, NULL, false);
}
@ -951,6 +994,8 @@ colorprofile_reset(ColorProfile *self) {
zero_at_ptr(&self->overridden);
for (unsigned i = 0; i < arraysz(self->overriden_transparent_colors); i++) { zero_at_ptr(self->overriden_transparent_colors + i); }
for (unsigned i = 0; i < self->color_stack_sz; i++) { zero_at_ptr(self->color_stack + i); }
zero_at_ptr(&self->overridden_mark_colors);
resolve_mark_colors(self);
}
bool
@ -1067,6 +1112,7 @@ reload_from_opts(ColorProfile *self, PyObject *args, PyObject *kw) {
zero_at_ptr(&self->overridden);
memset(self->overriden_transparent_colors, 0, sizeof(self->overriden_transparent_colors));
zero_at_ptr(&self->overridden_color_table_mask);
zero_at_ptr(&self->overridden_mark_colors);
}
if (!set_mark_colors(self, opts)) return NULL;
if (!set_colortable(self, opts)) return NULL;

View file

@ -306,6 +306,11 @@ typedef struct TransparentDynamicColor {
// One bit per entry of the 256 color palette
typedef uint64_t ColorTableMask[4];
// The background and foreground colors of the marks, entry i is for mark i + 1
typedef struct MarkColors {
DynamicColor bg[MARK_MASK], fg[MARK_MASK];
} MarkColors;
// A layer of colors. The configured colors of a window are the global layer
// (kitty.conf and the automatic color theme) with the window layer (launch
// --color, --copy-colors) on top and the session layer (color schemes from
@ -320,6 +325,7 @@ typedef struct ColorLayer {
TransparentDynamicColor transparent_colors[8];
// Whether transparent_colors is set, unused for the global layer
bool transparent_colors_set;
MarkColors mark_colors;
} ColorLayer;
typedef struct {
@ -338,12 +344,17 @@ typedef struct {
uint32_t color_table[256];
ColorTableMask color_table_mask;
TransparentDynamicColor transparent_colors[8];
MarkColors mark_colors;
} *color_stack;
unsigned int color_stack_idx, color_stack_sz;
// configured is the global, window and session layers combined. overridden
// has entries of type COLOR_NOT_SET for colors not set by the program.
DynamicColors configured, overridden;
ColorLayer global_layer, window_layer, session_layer;
// The mark colors set by the program, entries of type COLOR_NOT_SET for colors not set by the program
MarkColors overridden_mark_colors;
// The current mark colors resolved from the layers and overridden_mark_colors, in
// the layout used by the shaders, entry i is for mark i + 1 and the last entry is unused
color_type mark_foregrounds[MARK_MASK + 1], mark_backgrounds[MARK_MASK + 1];
} ColorProfile;

View file

@ -2402,6 +2402,79 @@ class TestScreen(BaseTest):
profiles[0].reload_from_opts(opts, reset_overriden_colors=reset)
ae(profiles[0], configured())
def test_mark_color_layers(self):
from kitty.fast_data_types import COLOR_LAYER_GLOBAL, COLOR_LAYER_OVERRIDE, COLOR_LAYER_SESSION, COLOR_LAYER_WINDOW, patch_color_profiles
opts = self.set_options({'palette_generate': 'fixed'})
s = self.create_screen()
cp = s.color_profile
cp.reload_from_opts(opts)
configured = cp.test_mark_colors()
def theme(bg, layer=COLOR_LAYER_GLOBAL, clear=False, profile=cp):
patch_color_profiles({'mark1_background': bg}, None, (profile,), layer, clear)
def check(bg, profile=cp):
# only the background of mark1 is ever changed
self.ae(profile.test_mark_colors(), ((configured[0][0], bg),) + configured[1:])
theme(1)
check(1)
self.assertNotIn('mark1_background', cp.as_dict())
# colors set by the program survive changes to the configured colors
theme(2, COLOR_LAYER_OVERRIDE)
theme(3)
check(2)
# and are restored by popping the color stack and removed by a full reset
parse_bytes(s, b'\x1b[#P')
theme(4, COLOR_LAYER_OVERRIDE)
check(4)
parse_bytes(s, b'\x1b[#Q')
check(2)
parse_bytes(s, b'\x1bc')
check(3)
# window layer colors survive changes to the global layer and full reset
theme(5, COLOR_LAYER_WINDOW)
theme(6)
check(5)
self.ae(cp.as_dict()['mark1_background'], 5)
self.assertNotIn('mark1_foreground', cp.as_dict())
theme(7, COLOR_LAYER_OVERRIDE)
parse_bytes(s, b'\x1bc')
check(5)
# session layer colors are above the window layer
theme(8, COLOR_LAYER_SESSION)
check(8)
cp.reset_layer(COLOR_LAYER_SESSION)
check(5)
# reloading from opts keeps the window layer, and program colors unless reset
theme(9, COLOR_LAYER_OVERRIDE)
cp.reload_from_opts(opts, reset_overriden_colors=False)
check(9)
cp.reload_from_opts(opts)
check(5)
# copying colors copies all layers
theme(10, COLOR_LAYER_OVERRIDE)
s2 = self.create_screen()
s2.copy_colors_from(s)
check(10, s2.color_profile)
parse_bytes(s2, b'\x1bc')
check(5, s2.color_profile)
parse_bytes(s, b'\x1bc')
cp.reset_layer(COLOR_LAYER_WINDOW)
check(configured[0][1])
# changing the global layer and clearing upper layers replaces colors
# from all layers above it, like set-colors --configured
theme(11, COLOR_LAYER_WINDOW)
theme(12, COLOR_LAYER_SESSION)
theme(13, COLOR_LAYER_OVERRIDE)
theme(14, clear=True)
check(14)
cp.reset_layer(COLOR_LAYER_SESSION)
cp.reset_layer(COLOR_LAYER_WINDOW)
check(14)
self.assertNotIn('mark1_background', cp.as_dict())
def test_color_profile(self):
from kitty.fast_data_types import patch_color_profiles