Change the color of the padding and margins to match the current background color of the window, when only a single window is visible.

Fixes #323

kitty/border_vertex.glsl

@@ -1,5 +1,8 @@
 #version GLSL_VERSION
 uniform uvec2 viewport;
+uniform vec3 default_bg;
+uniform vec3 active_border_color;
+uniform vec3 inactive_border_color;
 in uvec4 rect;  // left, top, right, bottom
 in uint rect_color;
 out vec3 color;
@@ -24,12 +27,9 @@ vec2 to_opengl(uint x, uint y) {
     );
 }
 
-float to_color(uint c) {
-    return float(c & uint(0xff)) / 255.0;
-}
-
 void main() {
     uvec2 pos = pos_map[gl_VertexID];
     gl_Position = vec4(to_opengl(rect[pos.x], rect[pos.y]), 0, 1);
-    color = vec3(to_color(rect_color >> 16), to_color(rect_color >> 8), to_color(rect_color));
+    int rc = int(rect_color);
+    color = float(1 & rc) * default_bg + float((2 & rc) >> 1) * active_border_color + float((4 & rc) >> 2) * inactive_border_color;
 }

kitty/borders.py

@@ -9,7 +9,7 @@ from .fast_data_types import (
     BORDERS_PROGRAM, add_borders_rect, compile_program, init_borders_program,
     pt_to_px
 )
-from .utils import color_as_int, load_shaders
+from .utils import load_shaders
 
 
 def vertical_edge(os_window_id, tab_id, color, width, top, bottom, left):
@@ -44,9 +44,6 @@ class Borders:
         self.tab_id = tab_id
         self.border_width = pt_to_px(opts.window_border_width)
         self.padding_width = pt_to_px(opts.window_padding_width)
-        self.background = color_as_int(opts.background)
-        self.active_border = color_as_int(opts.active_border_color)
-        self.inactive_border = color_as_int(opts.inactive_border_color)
 
     def __call__(
         self,
@@ -56,9 +53,9 @@ class Borders:
         extra_blank_rects,
         draw_window_borders=True
     ):
-        add_borders_rect(self.os_window_id, self.tab_id, 0, 0, 0, 0, 0)
+        add_borders_rect(self.os_window_id, self.tab_id, 0, 0, 0, 0, 1)
         for br in chain(current_layout.blank_rects, extra_blank_rects):
-            add_borders_rect(self.os_window_id, self.tab_id, *br, self.background)
+            add_borders_rect(self.os_window_id, self.tab_id, *br, 1)
         bw, pw = self.border_width, self.padding_width
         fw = bw + pw
 
@@ -67,7 +64,7 @@ class Borders:
                 g = w.geometry
                 if bw > 0 and draw_window_borders:
                     # Draw the border rectangles
-                    color = self.active_border if w is active_window else self.inactive_border
+                    color = 2 if w is active_window else 4
                     border(
                         self.os_window_id, self.tab_id,
                         color, bw, g.left - fw, g.top - fw, g.right + fw,
@@ -75,9 +72,8 @@ class Borders:
                     )
                 if pw > 0:
                     # Draw the background rectangles over the padding region
-                    color = self.background
                     border(
                         self.os_window_id, self.tab_id,
-                        color, pw, g.left - pw, g.top - pw, g.right + pw,
+                        1, pw, g.left - pw, g.top - pw, g.right + pw,
                         g.bottom + pw
                     )

kitty/child-monitor.c

@@ -566,7 +566,7 @@ simple_render_screen(PyObject UNUSED *self, PyObject *args) {
 }
 
 static inline bool
-prepare_to_render_os_window(OSWindow *os_window, double now, unsigned int *active_window_id) {
+prepare_to_render_os_window(OSWindow *os_window, double now, unsigned int *active_window_id, color_type *active_window_bg, unsigned int *num_visible_windows) {
 #define TD os_window->tab_bar_render_data
     bool needs_render = false;
     if (TD.screen && os_window->num_tabs > 1) {
@@ -574,10 +574,12 @@ prepare_to_render_os_window(OSWindow *os_window, double now, unsigned int *activ
     }
     if (OPT(mouse_hide_wait) > 0 && now - os_window->last_mouse_activity_at > OPT(mouse_hide_wait)) hide_mouse(os_window);
     Tab *tab = os_window->tabs + os_window->active_tab;
+    *active_window_bg = OPT(background);
     for (unsigned int i = 0; i < tab->num_windows; i++) {
         Window *w = tab->windows + i;
 #define WD w->render_data
         if (w->visible && WD.screen) {
+            *num_visible_windows += 1;
             if (w->last_drag_scroll_at > 0) {
                 if (now - w->last_drag_scroll_at >= 0.02) {
                     if (drag_scroll(w, os_window)) {
@@ -593,6 +595,7 @@ prepare_to_render_os_window(OSWindow *os_window, double now, unsigned int *activ
                 collect_cursor_info(&WD.screen->cursor_render_info, w, now, os_window);
                 if (w->cursor_visible_at_last_render != WD.screen->cursor_render_info.is_visible) needs_render = true;
                 update_window_title(w, os_window);
+                *active_window_bg = colorprofile_to_color(WD.screen->color_profile, WD.screen->color_profile->overridden.default_bg, WD.screen->color_profile->configured.default_bg);
             } else WD.screen->cursor_render_info.is_visible = false;
             if (send_cell_data_to_gpu(WD.vao_idx, WD.gvao_idx, WD.xstart, WD.ystart, WD.dx, WD.dy, WD.screen, os_window)) needs_render = true;
             if (WD.screen->start_visual_bell_at != 0) needs_render = true;
@@ -602,10 +605,10 @@ prepare_to_render_os_window(OSWindow *os_window, double now, unsigned int *activ
 }
 
 static inline void
-render_os_window(OSWindow *os_window, double now, unsigned int active_window_id) {
+render_os_window(OSWindow *os_window, double now, unsigned int active_window_id, color_type active_window_bg, unsigned int num_visible_windows) {
     Tab *tab = os_window->tabs + os_window->active_tab;
     BorderRects *br = &tab->border_rects;
-    draw_borders(br->vao_idx, br->num_border_rects, br->rect_buf, br->is_dirty, os_window->viewport_width, os_window->viewport_height);
+    draw_borders(br->vao_idx, br->num_border_rects, br->rect_buf, br->is_dirty, os_window->viewport_width, os_window->viewport_height, active_window_bg, num_visible_windows);
     if (TD.screen && os_window->num_tabs > 1) draw_cells(TD.vao_idx, 0, TD.xstart, TD.ystart, TD.dx, TD.dy, TD.screen, os_window, true);
     for (unsigned int i = 0; i < tab->num_windows; i++) {
         Window *w = tab->windows + i;
@@ -650,10 +653,11 @@ render(double now) {
             w->viewport_size_dirty = false;
             needs_render = true;
         }
-        unsigned int active_window_id = 0;
+        unsigned int active_window_id = 0, num_visible_windows = 0;
-        if (prepare_to_render_os_window(w, now, &active_window_id)) needs_render = true;
+        color_type active_window_bg = 0;
+        if (prepare_to_render_os_window(w, now, &active_window_id, &active_window_bg, &num_visible_windows)) needs_render = true;
         if (w->last_active_window_id != active_window_id || w->last_active_tab != w->active_tab || w->focused_at_last_render != w->is_focused) needs_render = true;
-        if (needs_render) render_os_window(w, now, active_window_id);
+        if (needs_render) render_os_window(w, now, active_window_id, active_window_bg, num_visible_windows);
     }
     last_render_at = now;
 #undef TD

kitty/shaders.c

@@ -489,7 +489,7 @@ draw_cursor(CursorRenderInfo *cursor, bool is_focused) {
 // }}}
 
 // Borders {{{
-enum BorderUniforms { BORDER_viewport, BORDER_background_opacity, NUM_BORDER_UNIFORMS };
+enum BorderUniforms { BORDER_viewport, BORDER_background_opacity, BORDER_default_bg, BORDER_active_border_color, BORDER_inactive_border_color, NUM_BORDER_UNIFORMS };
 static GLint border_uniform_locations[NUM_BORDER_UNIFORMS] = {0};
 
 static void
@@ -500,6 +500,9 @@ init_borders_program() {
 #define SET_LOC(which) (strcmp(p->uniforms[i].name, #which) == 0) border_uniform_locations[BORDER_##which] = p->uniforms[i].location
         if SET_LOC(viewport);
         else if SET_LOC(background_opacity);
+        else if SET_LOC(default_bg);
+        else if SET_LOC(active_border_color);
+        else if SET_LOC(inactive_border_color);
         else { fatal("Unknown uniform in borders program: %s", p->uniforms[i].name); return; }
     }
     if (left) { fatal("Left over uniforms in borders program"); return; }
@@ -520,7 +523,7 @@ create_border_vao() {
 }
 
 void
-draw_borders(ssize_t vao_idx, unsigned int num_border_rects, BorderRect *rect_buf, bool rect_data_is_dirty, uint32_t viewport_width, uint32_t viewport_height) {
+draw_borders(ssize_t vao_idx, unsigned int num_border_rects, BorderRect *rect_buf, bool rect_data_is_dirty, uint32_t viewport_width, uint32_t viewport_height, color_type active_window_bg, unsigned int num_visible_windows) {
     if (num_border_rects) {
         if (rect_data_is_dirty) {
             size_t sz = sizeof(GLuint) * 5 * num_border_rects;
@@ -530,11 +533,17 @@ draw_borders(ssize_t vao_idx, unsigned int num_border_rects, BorderRect *rect_bu
         }
         bind_program(BORDERS_PROGRAM);
         static bool constants_set = false;
+#define CV3(x) (((float)((x >> 16) & 0xff))/255.f), (((float)((x >> 8) & 0xff))/255.f), (((float)(x & 0xff))/255.f)
         if (!constants_set) {
             constants_set = true;
             glUniform1f(border_uniform_locations[BORDER_background_opacity], OPT(background_opacity));
+            glUniform3f(border_uniform_locations[BORDER_active_border_color], CV3(OPT(active_border_color)));
+            glUniform3f(border_uniform_locations[BORDER_inactive_border_color], CV3(OPT(inactive_border_color)));
         }
         glUniform2ui(border_uniform_locations[BORDER_viewport], viewport_width, viewport_height);
+        color_type default_bg = num_visible_windows > 1 ? OPT(background) : active_window_bg;
+        glUniform3f(border_uniform_locations[BORDER_default_bg], CV3(default_bg));
+#undef CV3
         bind_vertex_array(vao_idx);
         glDrawArraysInstanced(GL_TRIANGLE_FAN, 0, 4, num_border_rects);
         unbind_vertex_array();

kitty/state.c

@@ -347,6 +347,8 @@ PYWRAP1(set_options) {
     S(click_interval, PyFloat_AsDouble);
     S(url_color, color_as_int);
     S(background, color_as_int);
+    S(active_border_color, color_as_int);
+    S(inactive_border_color, color_as_int);
     S(repaint_delay, repaint_delay);
     S(input_delay, repaint_delay);
     S(sync_to_monitor, PyObject_IsTrue);

kitty/state.h

@@ -20,7 +20,7 @@ typedef struct {
     unsigned int rectangle_select_modifiers;
     unsigned int url_style;
     char_type select_by_word_characters[256]; size_t select_by_word_characters_count;
-    color_type url_color, background;
+    color_type url_color, background, active_border_color, inactive_border_color;
     double repaint_delay, input_delay;
     bool focus_follows_mouse;
     bool macos_option_as_alt, macos_hide_titlebar;
@@ -164,7 +164,7 @@ OSWindow* add_os_window();
 OSWindow* current_os_window();
 void os_window_regions(OSWindow*, Region *main, Region *tab_bar);
 bool drag_scroll(Window *, OSWindow*);
-void draw_borders(ssize_t vao_idx, unsigned int num_border_rects, BorderRect *rect_buf, bool rect_data_is_dirty, uint32_t viewport_width, uint32_t viewport_height);
+void draw_borders(ssize_t vao_idx, unsigned int num_border_rects, BorderRect *rect_buf, bool rect_data_is_dirty, uint32_t viewport_width, uint32_t viewport_height, color_type, unsigned int);
 ssize_t create_cell_vao();
 ssize_t create_graphics_vao();
 ssize_t create_border_vao();