adb35120

Fix text compare mode event loop and labels

a73x   2026-04-09 08:38

---

diff --git a/build.zig b/build.zig
index f8206f4..e74c775 100644
--- a/build.zig
+++ b/build.zig
@@ -191,7 +191,9 @@ pub fn build(b: *std.Build) void {
    });
    renderer_mod.addImport("vulkan", vulkan_module);
    renderer_mod.linkSystemLibrary("dl", .{});
    exe_mod.addImport("vulkan", vulkan_module);
    exe_mod.addImport("renderer", renderer_mod);
    main_test_mod.addImport("vulkan", vulkan_module);
    main_test_mod.addImport("renderer", renderer_mod);
    main_test_mod.addImport("font", font_mod);

diff --git a/src/main.zig b/src/main.zig
index 78aa1d8..d7e6927 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -5,7 +5,7 @@ const wayland_client = @import("wayland-client");
const renderer = @import("renderer");
const font = @import("font");
const config = @import("config");
const vk = @field(renderer, "vk");
const vk = @import("vulkan");

const c = @cImport({
    @cInclude("xkbcommon/xkbcommon-keysyms.h");
@@ -547,10 +547,14 @@ fn buildTextCoverageCompareScene(
    const panel_cols = comparisonPanelCols(specimen_lines);
    const panel_origins = comparisonPanelOrigins(panel_cols, top_margin_rows);
    const panel_glyph_count = comparisonVisibleGlyphCount(specimen_lines);
    var total_glyph_count = panel_glyph_count * @as(u32, @intCast(variants.len));
    for (variants) |variant| {
        total_glyph_count += comparisonVisibleGlyphCount(&.{variant.label});
    }

    var instances: std.ArrayListUnmanaged(renderer.Instance) = .empty;
    errdefer instances.deinit(alloc);
    try instances.ensureTotalCapacity(alloc, @as(usize, panel_glyph_count) * variants.len);
    try instances.ensureTotalCapacity(alloc, total_glyph_count);

    const baseline = face.baseline();
    const fg = [4]f32{ 1.0, 1.0, 1.0, 1.0 };
@@ -560,6 +564,35 @@ fn buildTextCoverageCompareScene(
    for (variants, 0..) |variant, panel_idx| {
        const origin = panel_origins[panel_idx];
        const instance_offset_instances: u32 = @intCast(instances.items.len);
        const label_row = origin[1] - @as(f32, @floatFromInt(top_margin_rows));

        for (variant.label, 0..) |char, col_idx| {
            if (char == ' ') continue;

            const glyph_uv = try atlas.getOrInsert(face, char);
            try instances.append(alloc, .{
                .cell_pos = .{
                    origin[0] + @as(f32, @floatFromInt(col_idx)),
                    label_row,
                },
                .glyph_size = .{
                    @floatFromInt(glyph_uv.width),
                    @floatFromInt(glyph_uv.height),
                },
                .glyph_bearing = .{
                    @floatFromInt(glyph_uv.bearing_x),
                    glyphTopOffset(baseline, glyph_uv.bearing_y),
                },
                .uv_rect = .{
                    glyph_uv.u0,
                    glyph_uv.v0,
                    glyph_uv.u1,
                    glyph_uv.v1,
                },
                .fg = fg,
                .bg = bg,
            });
        }

        for (specimen_lines, 0..) |line, row_idx| {
            for (line, 0..) |char, col_idx| {
@@ -1762,13 +1795,23 @@ fn runTextCoverageCompare(alloc: std.mem.Allocator) !void {
    atlas.dirty = false;
    try ctx.uploadInstances(scene.instances.items);

    const wl_fd = conn.display.getFd();
    var pollfds = [_]std.posix.pollfd{
        .{ .fd = wl_fd, .events = std.posix.POLL.IN, .revents = 0 },
    };
    var last_window_w = window.width;
    var last_window_h = window.height;

    while (!window.should_close) {
        _ = conn.display.flush();
        if (conn.display.prepareRead()) {
            _ = conn.display.readEvents();
            pollfds[0].revents = 0;
            _ = std.posix.poll(&pollfds, 16) catch {};
            if (pollfds[0].revents & std.posix.POLL.IN != 0) {
                _ = conn.display.readEvents();
            } else {
                conn.display.cancelRead();
            }
        }
        _ = conn.display.dispatchPending();

@@ -2122,7 +2165,7 @@ test "buildTextCoverageCompareScene repeats the same specimen in four panels" {

    var idx: usize = 0;
    while (idx < scene.panel_draws.len) : (idx += 1) {
        try std.testing.expectEqual(first_draw.instance_count, scene.panel_draws[idx].instance_count);
        try std.testing.expect(scene.panel_draws[idx].instance_count >= first_draw.instance_count - 8);
        try std.testing.expectEqualDeep(variants[idx].coverage, scene.panel_draws[idx].coverage);
    }