config: make unfocused-split-fill default to bg

macos/Sources/Ghostty/SurfaceView.swift

@@ -67,7 +67,10 @@ extension Ghostty {
         private var unfocusedFill: Color {
             var rgb: UInt32 = 16777215  // white default
             let key = "unfocused-split-fill"
-            _ = ghostty_config_get(ghostty.config, &rgb, key, UInt(key.count))
+            if (!ghostty_config_get(ghostty.config, &rgb, key, UInt(key.count))) {
+                let bg_key = "background"
+                _ = ghostty_config_get(ghostty.config, &rgb, bg_key, UInt(bg_key.count));
+            }
 
             let red = Double(rgb & 0xff)
             let green = Double((rgb >> 8) & 0xff)

src/config/Config.zig

@@ -312,13 +312,15 @@ palette: Palette = .{},
 /// minimum value is 0.15. This value still looks weird but you can at least
 /// see what's going on. A value outside of the range 0.15 to 1 will be
 /// clamped to the nearest valid value.
-@"unfocused-split-opacity": f64 = 0.85,
+@"unfocused-split-opacity": f64 = 0.7,
 
 // The color to dim the unfocused split. Unfocused splits are dimmed by
 // rendering a semi-transparent rectangle over the split. This sets
 // the color of that rectangle and can be used to carefully control
 // the dimming effect.
-@"unfocused-split-fill": Color = .{ .r = 255, .g = 255, .b = 255 },
+//
+// This will default to the background color.
+@"unfocused-split-fill": ?Color = null,
 
 /// The command to run, usually a shell. If this is not an absolute path,
 /// it'll be looked up in the PATH. If this is not set, a default will

src/config/c_get.zig

@@ -18,6 +18,14 @@ pub fn get(config: *const Config, k: Key, ptr_raw: *anyopaque) bool {
     switch (k) {
         inline else => |tag| {
             const value = fieldByKey(config, tag);
+            return getValue(ptr_raw, value);
+        },
+    }
+}
+
+/// Get the value anytype and put it into the pointer. Returns false if
+/// the type is not supported by the C API yet or the value is null.
+fn getValue(ptr_raw: *anyopaque, value: anytype) bool {
     switch (@TypeOf(value)) {
         ?[:0]const u8 => {
             const ptr: *?[*:0]const u8 = @ptrCast(@alignCast(ptr_raw));
@@ -40,6 +48,12 @@ pub fn get(config: *const Config, k: Key, ptr_raw: *anyopaque) bool {
         },
 
         else => |T| switch (@typeInfo(T)) {
+            .Optional => {
+                // If an optional has no value we return false.
+                const unwrapped = value orelse return false;
+                return getValue(ptr_raw, unwrapped);
+            },
+
             .Enum => {
                 const ptr: *[*:0]const u8 = @ptrCast(@alignCast(ptr_raw));
                 ptr.* = @tagName(value);
@@ -62,8 +76,6 @@ pub fn get(config: *const Config, k: Key, ptr_raw: *anyopaque) bool {
     }
 
     return true;
-        },
-    }
 }
 
 /// Get a value from the config by key.
@@ -109,3 +121,37 @@ test "enum" {
     const str = std.mem.sliceTo(cval, 0);
     try testing.expectEqualStrings("dark", str);
 }
+
+test "color" {
+    const testing = std.testing;
+    const alloc = testing.allocator;
+
+    var c = try Config.default(alloc);
+    defer c.deinit();
+    c.background = .{ .r = 255, .g = 0, .b = 0 };
+
+    var cval: c_uint = undefined;
+    try testing.expect(get(&c, .background, @ptrCast(&cval)));
+    try testing.expectEqual(@as(c_uint, 255), cval);
+}
+
+test "optional" {
+    const testing = std.testing;
+    const alloc = testing.allocator;
+
+    var c = try Config.default(alloc);
+    defer c.deinit();
+
+    {
+        c.@"unfocused-split-fill" = null;
+        var cval: c_uint = undefined;
+        try testing.expect(!get(&c, .@"unfocused-split-fill", @ptrCast(&cval)));
+    }
+
+    {
+        c.@"unfocused-split-fill" = .{ .r = 255, .g = 0, .b = 0 };
+        var cval: c_uint = undefined;
+        try testing.expect(get(&c, .@"unfocused-split-fill", @ptrCast(&cval)));
+        try testing.expectEqual(@as(c_uint, 255), cval);
+    }
+}