steven/beansprout-custom
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Create config/tag_overlay.zig

Browse source 
This moves all over the tag_overlay {} block parsing into its own file
This commit is contained in:
Ben Buhse 2026-02-16 13:38:17 -06:00
commit ef5b4369a6
No known key found for this signature in database
GPG key ID: 7916ACFCD38FD0B4
3 changed files with 285 additions and 249 deletions
Download patch file Download diff file Expand all files Collapse all files

250
src/Config.zig
View file

@ -88,66 +88,6 @@ pub const AttachMode = enum {
bottom,
};
pub const TagOverlayConfig = struct {
border_width: u8 = 2,
tag_amount: u8 = 9,
tags_per_row: u8 = 32,
square_size: u8 = 40,
square_inner_padding: u8 = 10,
square_padding: u8 = 15,
square_border_width: u8 = 1,
background_color: pixman.Color = utils.parseRgbaPixmanComptime("0x1e1e2e"),
border_color: pixman.Color = utils.parseRgbaPixmanComptime("0x6c7086"),
square_active_background_color: pixman.Color = utils.parseRgbaPixmanComptime("0x89b4fa"),
square_active_border_color: pixman.Color = utils.parseRgbaPixmanComptime("0x6c7086"),
square_active_occupied_color: pixman.Color = utils.parseRgbaPixmanComptime("0xcdd6f4"),
square_inactive_background_color: pixman.Color = utils.parseRgbaPixmanComptime("0x585b70"),
square_inactive_border_color: pixman.Color = utils.parseRgbaPixmanComptime("0x6c7086"),
square_inactive_occupied_color: pixman.Color = utils.parseRgbaPixmanComptime("0xcdd6f4"),
timeout: u32 = 500,
anchor_top: bool = false,
anchor_right: bool = false,
anchor_bottom: bool = false,
anchor_left: bool = false,
margin_top: i32 = 0,
margin_right: i32 = 0,
margin_bottom: i32 = 0,
margin_left: i32 = 0,
pub fn toTagOverlayOptions(self: TagOverlayConfig) TagOverlay.Options {
return .{
.border_width = self.border_width,
.tag_amount = @intCast(std.math.clamp(@as(u32, self.tag_amount), 1, 32)),
.tags_per_row = @intCast(std.math.clamp(@as(u32, self.tags_per_row), 1, 32)),
.square_size = self.square_size,
.square_inner_padding = self.square_inner_padding,
.square_padding = self.square_padding,
.square_border_width = self.square_border_width,
.background_color = self.background_color,
.border_color = self.border_color,
.square_active_background_color = self.square_active_background_color,
.square_active_border_color = self.square_active_border_color,
.square_active_occupied_color = self.square_active_occupied_color,
.square_inactive_background_color = self.square_inactive_background_color,
.square_inactive_border_color = self.square_inactive_border_color,
.square_inactive_occupied_color = self.square_inactive_occupied_color,
.anchors = .{
.top = self.anchor_top,
.right = self.anchor_right,
.bottom = self.anchor_bottom,
.left = self.anchor_left,
},
.margins = .{
.top = self.margin_top,
.right = self.margin_right,
.bottom = self.margin_bottom,
.left = self.margin_left,
},
.timeout = self.timeout,
};
}
};
const NodeName = enum {
attach_mode,
primary_count,
@ -163,30 +103,6 @@ const NodeName = enum {
tag_overlay,
};
const TagOverlayNodeName = enum {
border_width,
tag_amount,
tags_per_row,
square_size,
square_inner_padding,
square_padding,
square_border_width,
background_color,
border_color,
square_active_background_color,
square_active_border_color,
square_active_occupied_color,
square_inactive_background_color,
square_inactive_border_color,
square_inactive_occupied_color,
timeout,
anchors,
margins,
};
const TagOverlayAnchorsNodeName = enum { top, right, bottom, left };
const TagOverlayMarginsNodeName = enum { top, right, bottom, left };
const PointerBindNodeName = enum {
move_window,
resize_window,
@ -408,14 +324,14 @@ fn load(config: *Config, reader: *Io.Reader) !void {
.child_block_begin => {
if (next_child_block) |child_block| {
switch (child_block) {
.borders => try borders.load(config, &parser, hostname),
.borders => try borders_helper.load(config, &parser, hostname),
.keybinds => try config.loadKeybindsChildBlock(&parser, hostname),
.pointer_binds => try config.loadPointerBindsChildBlock(&parser, hostname),
.input => {
try config.loadInputChildBlock(&parser, pending_input_name, hostname);
pending_input_name = null; // ownership transferred
},
.tag_overlay => try config.loadTagOverlayChildBlock(&parser, hostname),
.tag_overlay => try tag_overlay_helper.load(config, &parser, hostname),
else => {
// Nothing else should ever be marked as a next_child_block
unreachable;
@ -431,152 +347,6 @@ fn load(config: *Config, reader: *Io.Reader) !void {
}
}
fn loadTagOverlayChildBlock(config: *Config, parser: *kdl.Parser, hostname: ?[]const u8) !void {
config.tag_overlay = .{}; // Presence of block = enabled; initialize with defaults
const TagOverlayChild = enum { anchors, margins };
var next_child_block: ?TagOverlayChild = null;
while (try parser.next()) |event| {
switch (event) {
.node => |node| {
if (next_child_block) |child| {
log.warn("Expected child block for tag_overlay.{s}, got node instead. Ignoring", .{@tagName(child)});
next_child_block = null;
}
const node_name = std.meta.stringToEnum(TagOverlayNodeName, node.name);
if (node_name) |name| {
if (!helpers.hostMatches(node, parser, hostname)) {
logDebugHostMismatch(name);
continue;
}
const val_str = utils.stripQuotes(node.arg(parser, 0) orelse "");
switch (name) {
.anchors => next_child_block = .anchors,
.margins => next_child_block = .margins,
// These are all u8s, so we can inline the branch
inline .border_width,
.tag_amount,
.tags_per_row,
.square_size,
.square_inner_padding,
.square_padding,
.square_border_width,
=> |tag| {
const val = fmt.parseInt(u8, val_str, 10) catch {
logWarnInvalidNodeArg(name, val_str);
continue;
};
@field(config.tag_overlay.?, @tagName(tag)) = val;
logDebugSettingNode(name, val_str);
},
.timeout => {
config.tag_overlay.?.timeout = fmt.parseInt(u32, val_str, 10) catch {
logWarnInvalidNodeArg(name, val_str);
continue;
};
logDebugSettingNode(name, val_str);
},
inline .background_color,
.border_color,
.square_active_background_color,
.square_active_border_color,
.square_active_occupied_color,
.square_inactive_background_color,
.square_inactive_border_color,
.square_inactive_occupied_color,
=> |tag| {
@field(config.tag_overlay.?, @tagName(tag)) = utils.parseRgbaPixman(val_str) catch {
logWarnInvalidNodeArg(name, val_str);
continue;
};
logDebugSettingNode(name, val_str);
},
}
} else {
helpers.logWarnInvalidNode(node.name);
}
},
.child_block_begin => {
if (next_child_block) |child| {
switch (child) {
.anchors => try config.loadTagOverlayAnchorsBlock(parser, hostname),
.margins => try config.loadTagOverlayMarginsBlock(parser, hostname),
}
next_child_block = null;
} else {
try helpers.skipChildBlock(parser);
}
},
.child_block_end => return,
}
}
}
fn loadTagOverlayAnchorsBlock(config: *Config, parser: *kdl.Parser, hostname: ?[]const u8) !void {
while (try parser.next()) |event| {
switch (event) {
.node => |node| {
const node_name = std.meta.stringToEnum(TagOverlayAnchorsNodeName, node.name);
if (node_name) |name| {
if (!helpers.hostMatches(node, parser, hostname)) {
logDebugHostMismatch(name);
continue;
}
const val_str = utils.stripQuotes(node.arg(parser, 0) orelse "");
if (helpers.boolFromKdlStr(val_str)) |val| {
switch (name) {
.top => config.tag_overlay.?.anchor_top = val,
.right => config.tag_overlay.?.anchor_right = val,
.bottom => config.tag_overlay.?.anchor_bottom = val,
.left => config.tag_overlay.?.anchor_left = val,
}
logDebugSettingNode(name, val_str);
} else {
logWarnInvalidNodeArg(name, val_str);
}
} else {
helpers.logWarnInvalidNode(node.name);
}
},
.child_block_begin => try helpers.skipChildBlock(parser),
.child_block_end => return,
}
}
}
fn loadTagOverlayMarginsBlock(config: *Config, parser: *kdl.Parser, hostname: ?[]const u8) !void {
while (try parser.next()) |event| {
switch (event) {
.node => |node| {
const node_name = std.meta.stringToEnum(TagOverlayMarginsNodeName, node.name);
if (node_name) |name| {
if (!helpers.hostMatches(node, parser, hostname)) {
logDebugHostMismatch(name);
continue;
}
const val_str = utils.stripQuotes(node.arg(parser, 0) orelse "");
const val = fmt.parseInt(i32, val_str, 10) catch {
logWarnInvalidNodeArg(name, val_str);
continue;
};
switch (name) {
.top => config.tag_overlay.?.margin_top = val,
.right => config.tag_overlay.?.margin_right = val,
.bottom => config.tag_overlay.?.margin_bottom = val,
.left => config.tag_overlay.?.margin_left = val,
}
logDebugSettingNode(name, val_str);
} else {
helpers.logWarnInvalidNode(node.name);
}
},
.child_block_begin => try helpers.skipChildBlock(parser),
.child_block_end => return,
}
}
}
fn loadKeybindsChildBlock(config: *Config, parser: *kdl.Parser, hostname: ?[]const u8) !void {
while (try parser.next()) |event| {
switch (event) {
@ -909,9 +679,6 @@ fn logWarnInvalidNodeArg(node_name: anytype, node_value: []const u8) void {
KeybindNodeName => log.warn("Invalid \"keybind.{s}\" ({s}). Ignoring", .{ @tagName(node_name), node_value }),
PointerBindNodeName => log.warn("Invalid \"pointer_binds.{s}\" ({s}). Ignoring", .{ @tagName(node_name), node_value }),
InputConfigNodeName => log.warn("Invalid \"input.{s}\" ({s}). Ignoring", .{ @tagName(node_name), node_value }),
TagOverlayNodeName => log.warn("Invalid \"tag_overlay.{s}\" ({s}). Using default value", .{ @tagName(node_name), node_value }),
TagOverlayAnchorsNodeName => log.warn("Invalid \"tag_overlay.anchors.{s}\" ({s}). Using default value", .{ @tagName(node_name), node_value }),
TagOverlayMarginsNodeName => log.warn("Invalid \"tag_overlay.margins.{s}\" ({s}). Using default value", .{ @tagName(node_name), node_value }),
else => @compileError("This function does not (yet) support type \"" ++ @typeName(node_name_type) ++ "\""),
}
}
@ -923,7 +690,6 @@ fn logWarnMissingNodeArg(node_name: anytype, comptime arg: []const u8) void {
KeybindNodeName => log.warn("\"keybind.{s}\" missing " ++ arg ++ " argument. Ignoring", .{@tagName(node_name)}),
PointerBindNodeName => log.warn("\"pointer_binds.{s}\" missing " ++ arg ++ " argument. Ignoring", .{@tagName(node_name)}),
InputConfigNodeName => log.warn("\"input.{s}\" missing " ++ arg ++ " argument. Ignoring", .{@tagName(node_name)}),
TagOverlayNodeName => log.warn("\"tag_overlay.{s}\" missing " ++ arg ++ " argument. Ignoring", .{@tagName(node_name)}),
else => @compileError("This function does not (yet) support type \"" ++ @typeName(node_name_type) ++ "\""),
}
}
@ -942,9 +708,6 @@ fn logDebugHostMismatch(node_name: anytype) void {
NodeName => log.debug("Skipping \"{s}\" (host mismatch)", .{@tagName(node_name)}),
PointerBindNodeName => log.debug("Skipping \"pointer_binds.{s}\" (host mismatch)", .{@tagName(node_name)}),
InputConfigNodeName => log.debug("Skipping \"input.{s}\" (host mismatch)", .{@tagName(node_name)}),
TagOverlayNodeName => log.debug("Skipping \"tag_overlay.{s}\" (host mismatch)", .{@tagName(node_name)}),
TagOverlayAnchorsNodeName => log.debug("Skipping \"tag_overlay.anchors.{s}\" (host mismatch)", .{@tagName(node_name)}),
TagOverlayMarginsNodeName => log.debug("Skipping \"tag_overlay.margins.{s}\" (host mismatch)", .{@tagName(node_name)}),
KeybindNodeName => log.debug("Skipping \"keybind.{s}\" (host mismatch)", .{@tagName(node_name)}),
else => @compileError("This function does not (yet) support type \"" ++ @typeName(node_name_type) ++ "\""),
}
@ -954,9 +717,6 @@ fn logDebugSettingNode(node_name: anytype, node_value: []const u8) void {
const node_name_type = @TypeOf(node_name);
switch (node_name_type) {
NodeName => log.debug("Setting {s} to {s}", .{ @tagName(node_name), node_value }),
TagOverlayNodeName => log.debug("Setting tag_overlay.{s} to {s}", .{ @tagName(node_name), node_value }),
TagOverlayAnchorsNodeName => log.debug("Setting tag_overlay.anchors.{s} to {s}", .{ @tagName(node_name), node_value }),
TagOverlayMarginsNodeName => log.debug("Setting tag_overlay.margins.{s} to {s}", .{ @tagName(node_name), node_value }),
else => @compileError("This function does not (yet) support type \"" ++ @typeName(@TypeOf(node_name)) ++ "\""),
}
}
@ -988,16 +748,16 @@ const ThreeFingerDragState = river.LibinputDeviceV1.ThreeFingerDragState;
const kdl = @import("kdl");
const known_folders = @import("known_folders");
const pixman = @import("pixman");
const xkbcommon = @import("xkbcommon");
const utils = @import("utils.zig");
const RiverColor = utils.RiverColor;
const TagOverlay = @import("TagOverlay.zig");
const XkbBindings = @import("XkbBindings.zig");
const borders = @import("config/borders.zig");
const borders_helper = @import("config/borders.zig");
const tag_overlay_helper = @import("config/tag_overlay.zig");
const helpers = @import("config/helpers.zig");
const TagOverlayConfig = tag_overlay_helper.TagOverlayConfig;
const log = std.log.scoped(.Config);

8
src/config/borders.zig
View file

@ -2,7 +2,7 @@
//
// SPDX-License-Identifier: GPL-3.0-only
pub const BorderNodeName = enum {
pub const NodeName = enum {
width,
color_focused,
color_unfocused,
@ -13,7 +13,7 @@ pub fn load(config: *Config, parser: *kdl.Parser, hostname: ?[]const u8) !void {
switch (event) {
.node => |node| {
// If it's a node, we check if it's a valid NodeName
const node_name = std.meta.stringToEnum(BorderNodeName, node.name);
const node_name = std.meta.stringToEnum(NodeName, node.name);
if (node_name) |name| {
if (!helpers.hostMatches(node, parser, hostname)) {
log.debug("Skipping \"border.{s}\" (host mismatch)", .{@tagName(name)});
@ -61,11 +61,11 @@ pub fn load(config: *Config, parser: *kdl.Parser, hostname: ?[]const u8) !void {
}
}
inline fn logDebugSettingNode(node_name: BorderNodeName, node_value: []const u8) void {
inline fn logDebugSettingNode(node_name: NodeName, node_value: []const u8) void {
log.debug("Setting border.{s} to {s}", .{ @tagName(node_name), node_value });
}
inline fn logWarnInvalidNodeArg(node_name: BorderNodeName, node_value: []const u8) void {
inline fn logWarnInvalidNodeArg(node_name: NodeName, node_value: []const u8) void {
log.warn("Invalid \"border.{s}\" ({s}). Ignoring", .{ @tagName(node_name), node_value });
}

276
src/config/tag_overlay.zig Normal file
View file

@ -0,0 +1,276 @@
// SPDX-FileCopyrightText: 2026 Ben Buhse <me@benbuhse.email>
//
// SPDX-License-Identifier: GPL-3.0-only
pub const NodeName = enum {
border_width,
tag_amount,
tags_per_row,
square_size,
square_inner_padding,
square_padding,
square_border_width,
background_color,
border_color,
square_active_background_color,
square_active_border_color,
square_active_occupied_color,
square_inactive_background_color,
square_inactive_border_color,
square_inactive_occupied_color,
timeout,
anchors,
margins,
};
pub const AnchorsNodeName = enum { top, right, bottom, left };
pub const MarginsNodeName = enum { top, right, bottom, left };
pub const TagOverlayConfig = struct {
border_width: u8 = 2,
tag_amount: u8 = 9,
tags_per_row: u8 = 32,
square_size: u8 = 40,
square_inner_padding: u8 = 10,
square_padding: u8 = 15,
square_border_width: u8 = 1,
background_color: pixman.Color = utils.parseRgbaPixmanComptime("0x1e1e2e"),
border_color: pixman.Color = utils.parseRgbaPixmanComptime("0x6c7086"),
square_active_background_color: pixman.Color = utils.parseRgbaPixmanComptime("0x89b4fa"),
square_active_border_color: pixman.Color = utils.parseRgbaPixmanComptime("0x6c7086"),
square_active_occupied_color: pixman.Color = utils.parseRgbaPixmanComptime("0xcdd6f4"),
square_inactive_background_color: pixman.Color = utils.parseRgbaPixmanComptime("0x585b70"),
square_inactive_border_color: pixman.Color = utils.parseRgbaPixmanComptime("0x6c7086"),
square_inactive_occupied_color: pixman.Color = utils.parseRgbaPixmanComptime("0xcdd6f4"),
timeout: u32 = 500,
anchor_top: bool = false,
anchor_right: bool = false,
anchor_bottom: bool = false,
anchor_left: bool = false,
margin_top: i32 = 0,
margin_right: i32 = 0,
margin_bottom: i32 = 0,
margin_left: i32 = 0,
pub fn toTagOverlayOptions(self: TagOverlayConfig) TagOverlay.Options {
return .{
.border_width = self.border_width,
.tag_amount = @intCast(std.math.clamp(@as(u32, self.tag_amount), 1, 32)),
.tags_per_row = @intCast(std.math.clamp(@as(u32, self.tags_per_row), 1, 32)),
.square_size = self.square_size,
.square_inner_padding = self.square_inner_padding,
.square_padding = self.square_padding,
.square_border_width = self.square_border_width,
.background_color = self.background_color,
.border_color = self.border_color,
.square_active_background_color = self.square_active_background_color,
.square_active_border_color = self.square_active_border_color,
.square_active_occupied_color = self.square_active_occupied_color,
.square_inactive_background_color = self.square_inactive_background_color,
.square_inactive_border_color = self.square_inactive_border_color,
.square_inactive_occupied_color = self.square_inactive_occupied_color,
.anchors = .{
.top = self.anchor_top,
.right = self.anchor_right,
.bottom = self.anchor_bottom,
.left = self.anchor_left,
},
.margins = .{
.top = self.margin_top,
.right = self.margin_right,
.bottom = self.margin_bottom,
.left = self.margin_left,
},
.timeout = self.timeout,
};
}
};
pub fn load(config: *Config, parser: *kdl.Parser, hostname: ?[]const u8) !void {
config.tag_overlay = .{}; // Presence of block = enabled; initialize with defaults
const TagOverlayChild = enum { anchors, margins };
var next_child_block: ?TagOverlayChild = null;
while (try parser.next()) |event| {
switch (event) {
.node => |node| {
if (next_child_block) |child| {
log.warn("Expected child block for tag_overlay.{s}, got node instead. Ignoring", .{@tagName(child)});
next_child_block = null;
}
const node_name = std.meta.stringToEnum(NodeName, node.name);
if (node_name) |name| {
if (!helpers.hostMatches(node, parser, hostname)) {
logDebugHostMismatch(name);
continue;
}
const val_str = utils.stripQuotes(node.arg(parser, 0) orelse "");
switch (name) {
.anchors => next_child_block = .anchors,
.margins => next_child_block = .margins,
// These are all u8s, so we can inline the branch
inline .border_width,
.tag_amount,
.tags_per_row,
.square_size,
.square_inner_padding,
.square_padding,
.square_border_width,
=> |tag| {
const val = fmt.parseInt(u8, val_str, 10) catch {
logWarnInvalidNodeArg(name, val_str);
continue;
};
@field(config.tag_overlay.?, @tagName(tag)) = val;
logDebugSettingNode(name, val_str);
},
.timeout => {
config.tag_overlay.?.timeout = fmt.parseInt(u32, val_str, 10) catch {
logWarnInvalidNodeArg(name, val_str);
continue;
};
logDebugSettingNode(name, val_str);
},
inline .background_color,
.border_color,
.square_active_background_color,
.square_active_border_color,
.square_active_occupied_color,
.square_inactive_background_color,
.square_inactive_border_color,
.square_inactive_occupied_color,
=> |tag| {
@field(config.tag_overlay.?, @tagName(tag)) = utils.parseRgbaPixman(val_str) catch {
logWarnInvalidNodeArg(name, val_str);
continue;
};
logDebugSettingNode(name, val_str);
},
}
} else {
helpers.logWarnInvalidNode(node.name);
}
},
.child_block_begin => {
if (next_child_block) |child| {
switch (child) {
.anchors => try loadAnchorsBlock(config, parser, hostname),
.margins => try loadMarginsBlock(config, parser, hostname),
}
next_child_block = null;
} else {
try helpers.skipChildBlock(parser);
}
},
.child_block_end => return,
}
}
}
fn loadAnchorsBlock(config: *Config, parser: *kdl.Parser, hostname: ?[]const u8) !void {
while (try parser.next()) |event| {
switch (event) {
.node => |node| {
const node_name = std.meta.stringToEnum(AnchorsNodeName, node.name);
if (node_name) |name| {
if (!helpers.hostMatches(node, parser, hostname)) {
logDebugHostMismatch(name);
continue;
}
const val_str = utils.stripQuotes(node.arg(parser, 0) orelse "");
if (helpers.boolFromKdlStr(val_str)) |val| {
switch (name) {
.top => config.tag_overlay.?.anchor_top = val,
.right => config.tag_overlay.?.anchor_right = val,
.bottom => config.tag_overlay.?.anchor_bottom = val,
.left => config.tag_overlay.?.anchor_left = val,
}
logDebugSettingNode(name, val_str);
} else {
logWarnInvalidNodeArg(name, val_str);
}
} else {
helpers.logWarnInvalidNode(node.name);
}
},
.child_block_begin => try helpers.skipChildBlock(parser),
.child_block_end => return,
}
}
}
fn loadMarginsBlock(config: *Config, parser: *kdl.Parser, hostname: ?[]const u8) !void {
while (try parser.next()) |event| {
switch (event) {
.node => |node| {
const node_name = std.meta.stringToEnum(MarginsNodeName, node.name);
if (node_name) |name| {
if (!helpers.hostMatches(node, parser, hostname)) {
logDebugHostMismatch(name);
continue;
}
const val_str = utils.stripQuotes(node.arg(parser, 0) orelse "");
const val = fmt.parseInt(i32, val_str, 10) catch {
logWarnInvalidNodeArg(name, val_str);
continue;
};
switch (name) {
.top => config.tag_overlay.?.margin_top = val,
.right => config.tag_overlay.?.margin_right = val,
.bottom => config.tag_overlay.?.margin_bottom = val,
.left => config.tag_overlay.?.margin_left = val,
}
logDebugSettingNode(name, val_str);
} else {
helpers.logWarnInvalidNode(node.name);
}
},
.child_block_begin => try helpers.skipChildBlock(parser),
.child_block_end => return,
}
}
}
inline fn logDebugSettingNode(node_name: anytype, node_value: []const u8) void {
const node_name_type = @TypeOf(node_name);
switch (node_name_type) {
NodeName => log.debug("Setting tag_overlay.{s} to {s}", .{ @tagName(node_name), node_value }),
AnchorsNodeName => log.debug("Setting tag_overlay.anchors.{s} to {s}", .{ @tagName(node_name), node_value }),
MarginsNodeName => log.debug("Setting tag_overlay.margins.{s} to {s}", .{ @tagName(node_name), node_value }),
else => @compileError("This function does not (yet) support type \"" ++ @typeName(@TypeOf(node_name)) ++ "\""),
}
}
inline fn logDebugHostMismatch(node_name: anytype) void {
const node_name_type = @TypeOf(node_name);
switch (node_name_type) {
NodeName => log.debug("Skipping \"tag_overlay.{s}\" (host mismatch)", .{@tagName(node_name)}),
AnchorsNodeName => log.debug("Skipping \"tag_overlay.anchors.{s}\" (host mismatch)", .{@tagName(node_name)}),
MarginsNodeName => log.debug("Skipping \"tag_overlay.margins.{s}\" (host mismatch)", .{@tagName(node_name)}),
else => @compileError("This function does not (yet) support type \"" ++ @typeName(node_name_type) ++ "\""),
}
}
inline fn logWarnInvalidNodeArg(node_name: anytype, node_value: []const u8) void {
const node_name_type = @TypeOf(node_name);
switch (node_name_type) {
NodeName => log.warn("Invalid \"tag_overlay.{s}\" ({s}). Using default value", .{ @tagName(node_name), node_value }),
AnchorsNodeName => log.warn("Invalid \"tag_overlay.anchors.{s}\" ({s}). Using default value", .{ @tagName(node_name), node_value }),
MarginsNodeName => log.warn("Invalid \"tag_overlay.margins.{s}\" ({s}). Using default value", .{ @tagName(node_name), node_value }),
else => @compileError("This function does not (yet) support type \"" ++ @typeName(node_name_type) ++ "\""),
}
}
const std = @import("std");
const fmt = std.fmt;
const kdl = @import("kdl");
const pixman = @import("pixman");
const utils = @import("../utils.zig");
const Config = @import("../Config.zig");
const TagOverlay = @import("../TagOverlay.zig");
const helpers = @import("helpers.zig");
const log = std.log.scoped(.config_tag_overlay);