summaryrefslogtreecommitdiff
path: root/src/gui/gui.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/gui/gui.zig')
-rw-r--r--src/gui/gui.zig7526
1 files changed, 5707 insertions, 1819 deletions
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index d871e55e..01272b41 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -6,25 +6,26 @@ const libc = std.c;
const vaxis = @import("vaxis"); // test modes only: the stdin escape-seq parser
const ghostty_vt = @import("ghostty-vt"); // 256-color palette for .index cells
const pardes = @import("../pardes.zig");
+const vaxis_input = @import("../vaxis_input.zig");
+const dump = @import("../dump.zig");
const config = @import("../config.zig");
const look = @import("../look.zig");
-const message = pardes.Pardes.Message;
+const message = pardes.Messages.Message;
const file_watch = @import("../file_watch.zig");
+const ShaderBuild = @import("../ShaderBuild.zig");
const deck = @import("deck.zig");
-const crt = @import("crt.zig");
+const Post = @import("Post.zig");
const pet = @import("pet.zig");
const fonts = @import("../fonts.zig"); // the Font builtin's half of the seam
const selection_pipe = @import("../selection_pipe.zig");
+const c_heap = @import("c_heap");
const ninep_io = @import("../9p_io.zig");
const detached_client = @import("../detached/client.zig");
+const tracy = @import("../tracy.zig");
-pub const c = @cImport({
- @cDefine("SDL_DISABLE_OLD_NAMES", "1");
- @cInclude("SDL3/SDL.h");
- @cInclude("font.h");
-});
+pub const c = @import("gui_c"); // SDL3 and font.h, translated by build.zig
const host_io = @import("../host_io.zig");
extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int;
@@ -35,12 +36,11 @@ const log = std.log.scoped(.gui);
const font_ttf = @embedFile("AdwaitaMono-Regular.ttf");
const vert_spv = @embedFile("ui.vert.spv");
const frag_spv = @embedFile("ui.frag.spv");
+const decor_frag_spv = @embedFile("decor.frag.spv");
const overlay_vert_spv = @embedFile("overlay.vert.spv");
const overlay_frag_spv = @embedFile("overlay.frag.spv");
const image_vert_spv = @embedFile("image.vert.spv");
const image_frag_spv = @embedFile("image.frag.spv");
-const crt_vert_spv = @embedFile("crt.vert.spv");
-const crt_frag_spv = @embedFile("crt.frag.spv");
const bg_default = [3]u8{ 18, 18, 18 };
const fg_default = [3]u8{ 204, 204, 204 };
@@ -54,11 +54,6 @@ const Ground = struct {
}
};
-fn ground(theme_bg: ?[3]u8, transparent: bool) Ground {
- if (theme_bg) |rgb| return .opaqueRgb(rgb);
- return .{ .rgb = bg_default, .clear = transparent };
-}
-
const p9_arrow_clr = [32]u8{
0xFF, 0xFF, 0x80, 0x01, 0x80, 0x02, 0x80, 0x0C,
0x80, 0x10, 0x80, 0x10, 0x80, 0x08, 0x80, 0x04,
@@ -71,6 +66,24 @@ const p9_arrow_set = [32]u8{
0x7F, 0xFC, 0x7F, 0xFE, 0x7F, 0xFC, 0x73, 0xF8,
0x61, 0xF0, 0x60, 0xE0, 0x40, 0x40, 0x00, 0x00,
};
+/// acme's boxcursor (acme.c:956), while a grip carries a pane or column.
+const p9_box_clr = [32]u8{
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F,
+ 0xF8, 0x1F, 0xF8, 0x1F, 0xF8, 0x1F, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+};
+const p9_box_set = [32]u8{
+ 0x00, 0x00, 0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE,
+ 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E,
+ 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E, 0x70, 0x0E,
+ 0x7F, 0xFE, 0x7F, 0xFE, 0x7F, 0xFE, 0x00, 0x00,
+};
+const p9_box_mask = blk: {
+ var m: [32]u8 = undefined;
+ for (&m, p9_box_set, p9_box_clr) |*b, s, cl| b.* = s | cl;
+ break :blk m;
+};
const p9_arrow_mask = blk: {
var m: [32]u8 = undefined;
for (&m, p9_arrow_set, p9_arrow_clr) |*b, s, cl| b.* = s | cl;
@@ -80,14 +93,65 @@ const p9_arrow_mask = blk: {
const atlas_w: u32 = 2048;
const atlas_h: u32 = 2048;
const Slot = struct { u: u32, v: u32 };
-const GlyphKey = struct {
- codepoint: u32,
- centered: bool = false,
+/// An atlas entry is a glyph of a face (0 the primary font, i the fallback
+/// i - 1) at a role's size, drawn `span` cells wide with its own cell `lead`
+/// cells in: a ligature is one strip whose cells sample their own slices.
+/// Packed, so the atlas map hashes one word instead of walking fields.
+const GlyphKey = packed struct(u64) {
+ face: u8,
+ glyph: u32,
role: pardes.FontRole,
decoration: GlyphDecoration = .{},
+ centered: bool = false,
+ lead: u4 = 0,
+ span: u4 = 1,
+ /// A light box-drawing rule (`ruleArms`), drawn edge to edge rather
+ /// than from the font; `glyph` is its codepoint.
+ rule: bool = false,
+ _: u1 = 0,
};
-const GlyphDecoration = struct {
+/// The light box-drawing rules drawn by hand, as Ghostty and kitty draw
+/// them: a logical pixel thick through the cell's middle, out to its edges,
+/// so a markdown table's `|` (Tables.zig) joins the rows above and below it
+/// and its delimiter row is one line across, at any line height a font's
+/// own glyph would leave gaps in. The arms each one has: left, right, up, down.
+fn ruleArms(cp: u32) ?[4]bool {
+ return switch (cp) {
+ 0x2500 => .{ true, true, false, false }, // ─
+ 0x2502 => .{ false, false, true, true }, // │
+ 0x250c => .{ false, true, false, true }, // ┌
+ 0x2510 => .{ true, false, false, true }, // ┐
+ 0x2514 => .{ false, true, true, false }, // └
+ 0x2518 => .{ true, false, true, false }, // ┘
+ 0x251c => .{ false, true, true, true }, // ├
+ 0x2524 => .{ true, false, true, true }, // ┤
+ 0x252c => .{ true, true, false, true }, // ┬
+ 0x2534 => .{ true, true, true, false }, // ┴
+ 0x253c => .{ true, true, true, true }, // ┼
+ else => null,
+ };
+}
+
+fn drawRule(out: [*]u8, stride: usize, width: usize, height: usize, arms: [4]bool) void {
+ if (width == 0 or height == 0) return;
+ const t: usize = @min(@max(1, @as(usize, @intFromFloat(dp(1)))), @min(width, height));
+ const mx = (width - t) / 2;
+ const my = (height - t) / 2;
+ for (0..height) |y| @memset(out[y * stride ..][0..width], 0);
+ if (arms[0] or arms[1]) for (0..t) |k| {
+ const from: usize = if (arms[0]) 0 else mx;
+ const to: usize = if (arms[1]) width else mx + t;
+ @memset(out[(my + k) * stride + from ..][0 .. to - from], 255);
+ };
+ if (arms[2] or arms[3]) {
+ const from: usize = if (arms[2]) 0 else my;
+ const to: usize = if (arms[3]) height else my + t;
+ for (from..to) |y| @memset(out[y * stride + mx ..][0..t], 255);
+ }
+}
+
+const GlyphDecoration = packed struct(u5) {
bold: bool = false,
underline: @FieldType(pardes.CellStyle, "ul") = .off,
strikethrough: bool = false,
@@ -103,7 +167,7 @@ const GlyphDecoration = struct {
};
const TaglineRaster = struct {
- scale: f32,
+ px: f32,
width: u32,
baseline: i32,
height: u32,
@@ -111,21 +175,72 @@ const TaglineRaster = struct {
fn taglineRaster(font: *c.UIFont, body_px: f32, body_cell_w: u32, body_cell_h: u32, percent: u8) TaglineRaster {
const px = body_px * @as(f32, @floatFromInt(percent)) / 100.0;
- const scale = c.ui_font_scale_for_height(font, px);
var own_w: c_int = 1;
var own_h: c_int = 1;
var own_ascent: c_int = 1;
- c.ui_font_cell_metrics(font, scale, &own_w, &own_h, &own_ascent);
+ c.ui_font_cell_metrics(font, px, &own_w, &own_h, &own_ascent);
const fixed_w: c_int = @intCast(body_cell_w);
const fixed_h: c_int = @intCast(body_cell_h);
const band_h = std.math.clamp(own_h, 1, fixed_h);
return .{
- .scale = scale,
+ .px = px,
.width = @intCast(std.math.clamp(own_w, 1, fixed_w)),
.baseline = std.math.clamp(own_ascent, 1, band_h),
.height = @intCast(band_h),
};
}
+/// What FreeType and HarfBuzz allocate from, through ui_malloc and friends:
+/// the shared C heap, exported under the names font.c and HarfBuzz's
+/// hb_malloc_impl expect. runNative points it at the gui's gpa once
+/// HarfBuzz's process-wide objects exist (ui_font_prime), so a Debug build's
+/// leak report is about fonts; a test that counts what fonts leak points it
+/// at std.testing.allocator the same way. Only the render thread calls into
+/// fonts, and every allocator it is pointed at is thread-safe anyway.
+var font_allocator: std.mem.Allocator = std.heap.smp_allocator;
+const font_heap = c_heap.Heap(&font_allocator);
+comptime {
+ @export(&font_heap.malloc, .{ .name = "ui_malloc" });
+ @export(&font_heap.calloc, .{ .name = "ui_calloc" });
+ @export(&font_heap.realloc, .{ .name = "ui_realloc" });
+ @export(&font_heap.free, .{ .name = "ui_free" });
+}
+
+test "FreeType and HarfBuzz allocate from the gui allocator and give it all back" {
+ // HarfBuzz's process-wide objects come from the default heap, as in runNative.
+ const primer = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ c.ui_font_prime(primer);
+ c.ui_font_free(primer);
+ font_allocator = std.testing.allocator;
+ defer font_allocator = std.heap.smp_allocator;
+
+ const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ defer c.ui_font_free(font);
+ var mask: [64 * 64]u8 = undefined;
+ try std.testing.expectEqual(@as(c_int, 1), c.ui_font_raster(font, 27, c.ui_font_glyph(font, 'g'), 1, &mask, 64, 32, 48, 0, 32, 30));
+ try std.testing.expectEqual(@as(c_int, 0), c.ui_font_substitutes(font, c.ui_font_glyph(font, '-')));
+
+ // A font with ligatures runs the whole HarfBuzz pass.
+ const bytes = try filesystem.readFile(std.testing.allocator, "assets/MapleMono-NF-Regular.ttf");
+ defer std.testing.allocator.free(bytes);
+ const maple = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit;
+ defer c.ui_font_free(maple);
+ var cell_w: c_int = 0;
+ var cell_h: c_int = 0;
+ var ascent: c_int = 0;
+ c.ui_font_cell_metrics(maple, 27, &cell_w, &cell_h, &ascent);
+ const text = [_]u32{ 'a', '-', '>', 'b', '=', '=' };
+ var shaped: [text.len]c.UIShapedCell = undefined;
+ c.ui_font_shape(maple, 27, cell_w, &text, text.len, &shaped);
+ try std.testing.expectEqual(@as(u8, 2), shaped[1].span);
+ try std.testing.expectEqual(@as(u8, 2), shaped[4].span);
+}
+
+/// What SDL allocates from, on its own threads as well as the render thread:
+/// the gui's gpa, through the shared C heap, which is thread-safe in every
+/// build. runNative hands everything back and calls SDL_Quit on the way out.
+var sdl_allocator: std.mem.Allocator = undefined;
+const sdl_heap = c_heap.Heap(&sdl_allocator);
+
const max_fallback_fonts = 1 + fonts.fallback_names.len;
const LoadedFallback = struct {
face: *c.UIFont,
@@ -139,55 +254,17 @@ const touch_click_flash_max_frames: u8 = 14;
const touch_click_flash_vertices: usize = 1400;
const touch_scroll_tick: f32 = 0.02;
-const AnimationClock = struct {
- next_ns: u64 = 0,
-
- fn due(clock: *AnimationClock, active: bool, now_ns: u64) bool {
- if (!active) {
- clock.next_ns = 0;
- return false;
- }
- if (clock.next_ns == 0) {
- clock.next_ns = now_ns +| pardes.layout.Animation.frame_ns;
- return false;
- }
- if (now_ns < clock.next_ns) return false;
- clock.next_ns = now_ns +| pardes.layout.Animation.frame_ns;
- return true;
- }
-};
-
-fn finishPresentedAnimationFrame(
- clock: *AnimationClock,
- core: *pardes.Pardes,
- tracks: []const pardes.layout.Track,
- now_ns: u64,
-) void {
- core.acknowledgePanelPresentation(tracks);
- if (clock.due(core.animationActive(), now_ns)) core.update(.tick);
-}
-
-test "GUI animation clock is active-only and cadence gated" {
- var clock: AnimationClock = .{};
- try std.testing.expect(!clock.due(false, 100));
- try std.testing.expect(!clock.due(true, 100));
- try std.testing.expect(!clock.due(true, 100 + pardes.layout.Animation.frame_ns - 1));
- try std.testing.expect(clock.due(true, 100 + pardes.layout.Animation.frame_ns));
- try std.testing.expect(!clock.due(false, 100 + 2 * pardes.layout.Animation.frame_ns));
- try std.testing.expectEqual(@as(u64, 0), clock.next_ns);
-}
-
-test "a persistent scene presents a new panel's frame zero before advancing it" {
+test "a new panel's frame zero is presented before it advances" {
const core = try pardes.Pardes.init(std.testing.allocator, .{ .tty_only = true });
defer core.deinit();
var arena: std.heap.ArenaAllocator = .init(std.testing.allocator);
defer arena.deinit();
- var clock: AnimationClock = .{};
+ const frame = pardes.animation.frame_ns;
- core.settings.scene_effects.crt = true;
- const scene_frame = try core.render(arena.allocator());
- finishPresentedAnimationFrame(&clock, core, scene_frame.panelTracks(), 100);
- try std.testing.expectEqual(@as(u64, 100 + pardes.layout.Animation.frame_ns), clock.next_ns);
+ core.advance(100);
+ const idle = try core.render(arena.allocator());
+ core.acknowledgePanelPresentation(idle.panelTracks());
+ try std.testing.expectEqual(@as(?u64, null), core.nextWake());
core.settings.panel_transition = .slide;
core.update(.{ .command = "Newcol" });
@@ -197,21 +274,21 @@ test "a persistent scene presents a new panel's frame zero before advancing it"
try std.testing.expect(track_count > 0);
for (first.panelTracks()) |track| try std.testing.expectEqual(@as(u16, 0), track.frame);
- finishPresentedAnimationFrame(
- &clock,
- core,
- first.panelTracks(),
- 100 + pardes.layout.Animation.frame_ns,
- );
+ core.acknowledgePanelPresentation(first.panelTracks());
+ // Just short of a frame is no frame at all.
+ core.advance(100 + frame - 1);
+ _ = arena.reset(.retain_capacity);
+ for ((try core.render(arena.allocator())).panelTracks()) |track| try std.testing.expectEqual(@as(u16, 0), track.frame);
+ core.advance(100 + frame);
_ = arena.reset(.retain_capacity);
const second = try core.render(arena.allocator());
try std.testing.expectEqual(track_count, second.panelTracks().len);
for (second.panelTracks()) |track| try std.testing.expectEqual(@as(u16, 1), track.frame);
}
-// Per pane: background, rule, two grip strokes, and two square rails.
-const pane_chrome_vertices: usize = 6 * 6;
-const max_overlay_vertices: usize = 24 + pet.max_vertices + pardes.MAX_COLS * 6 + pardes.MAX_PANES * pane_chrome_vertices + touch_click_flash_vertices + max_touch_points * (1100 + max_touch_trail_points * overlay_circle_vertices);
+// The triangle overlay holds only the pet and the touch view: the chrome is
+// decor.
+const max_overlay_vertices: usize = pet.max_vertices + touch_click_flash_vertices + max_touch_points * (1100 + max_touch_trail_points * overlay_circle_vertices);
const font_px_step: f32 = 2.0;
const font_px_min: f32 = 8.0;
@@ -227,8 +304,8 @@ test "every font size step moves the cell, and the ends are reachable exactly" {
var asc: c_int = 0;
var pw: c_int = 0;
var ph: c_int = 0;
- c.ui_font_cell_metrics(font, c.ui_font_scale_for_height(font, px), &cw, &ch, &asc);
- c.ui_font_cell_metrics(font, c.ui_font_scale_for_height(font, px - font_px_step), &pw, &ph, &asc);
+ c.ui_font_cell_metrics(font, px, &cw, &ch, &asc);
+ c.ui_font_cell_metrics(font, px - font_px_step, &pw, &ph, &asc);
try std.testing.expect(cw > pw and ch > ph);
}
try std.testing.expectEqual(font_px_max, std.math.clamp(font_px_max + font_px_step, font_px_min, font_px_max));
@@ -238,10 +315,11 @@ test "every font size step moves the cell, and the ends are reachable exactly" {
test "FreeType atlas raster is grayscale, bounded, and clears blank cells" {
const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
defer c.ui_font_free(font);
- try std.testing.expectEqual(@as(c_int, 1), c.ui_font_has_glyph(font, 'H'));
- try std.testing.expectEqual(@as(c_int, 0), c.ui_font_has_glyph(font, 0x10ffff));
+ const h = c.ui_font_glyph(font, 'H');
+ try std.testing.expect(h != 0);
+ try std.testing.expectEqual(@as(u32, 0), c.ui_font_glyph(font, 0x10ffff));
- const size = c.ui_font_scale_for_height(font, 13.0);
+ const size: f32 = 13.0;
var cell_w: c_int = 0;
var cell_h: c_int = 0;
var ascent: c_int = 0;
@@ -253,7 +331,7 @@ test "FreeType atlas raster is grayscale, bounded, and clears blank cells" {
var bitmap: [128 * 128]u8 = @splat(0xaa);
try std.testing.expectEqual(
@as(c_int, 1),
- c.ui_font_raster(font, size, 'H', &bitmap, stride, cell_w, cell_h, ascent),
+ c.ui_font_raster(font, size, h, 0, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent),
);
var ink: usize = 0;
@@ -269,7 +347,11 @@ test "FreeType atlas raster is grayscale, bounded, and clears blank cells" {
}
try std.testing.expect(ink > 0);
try std.testing.expect(soft > 0);
- decorateGlyph(&bitmap, @intCast(stride), @intCast(cell_w), @intCast(cell_h), ascent, .{ .bold = true });
+ // Synthetic bold thickens the outline inside the same cell.
+ try std.testing.expectEqual(
+ @as(c_int, 1),
+ c.ui_font_raster(font, size, h, 1, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent),
+ );
var bold_coverage: usize = 0;
for (0..@intCast(cell_h)) |y| {
for (0..@intCast(cell_w)) |x| bold_coverage += bitmap[y * @as(usize, @intCast(stride)) + x];
@@ -280,7 +362,7 @@ test "FreeType atlas raster is grayscale, bounded, and clears blank cells" {
try std.testing.expectEqual(
@as(c_int, 0),
- c.ui_font_raster(font, size, ' ', &bitmap, stride, cell_w, cell_h, ascent),
+ c.ui_font_raster(font, size, c.ui_font_glyph(font, ' '), 0, &bitmap, stride, cell_w, cell_h, 0, cell_w, ascent),
);
for (0..@intCast(cell_h)) |y|
for (0..@intCast(cell_w)) |x|
@@ -310,38 +392,21 @@ test "tagline glyph shrinks into its own cell and stays vertically centered" {
const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
defer c.ui_font_free(font);
- const body_scale = c.ui_font_scale_for_height(font, 27.0);
+ const body_px: f32 = 27.0;
var cell_w: c_int = 1;
var cell_h: c_int = 1;
var body_ascent: c_int = 1;
- c.ui_font_cell_metrics(font, body_scale, &cell_w, &cell_h, &body_ascent);
- const tag = taglineRaster(font, 27.0, @intCast(cell_w), @intCast(cell_h), config.gui_tagline_font_percent);
- try std.testing.expect(tag.scale < body_scale);
+ c.ui_font_cell_metrics(font, body_px, &cell_w, &cell_h, &body_ascent);
+ const tag = taglineRaster(font, body_px, @intCast(cell_w), @intCast(cell_h), config.gui_tagline_font_percent);
+ try std.testing.expect(tag.px < body_px);
try std.testing.expect(tag.width < @as(u32, @intCast(cell_w)));
const stride: c_int = 128;
var body: [128 * 128]u8 = @splat(0);
var tagline: [128 * 128]u8 = @splat(0);
- try std.testing.expectEqual(@as(c_int, 1), c.ui_font_raster(
- font,
- body_scale,
- 'H',
- &body,
- stride,
- cell_w,
- cell_h,
- body_ascent,
- ));
- try std.testing.expectEqual(@as(c_int, 1), c.ui_font_raster(
- font,
- tag.scale,
- 'H',
- &tagline,
- stride,
- @intCast(tag.width),
- @intCast(tag.height),
- tag.baseline,
- ));
+ const h = c.ui_font_glyph(font, 'H');
+ try std.testing.expectEqual(@as(c_int, 1), c.ui_font_raster(font, body_px, h, 0, &body, stride, cell_w, cell_h, 0, cell_w, body_ascent));
+ try std.testing.expectEqual(@as(c_int, 1), c.ui_font_raster(font, tag.px, h, 0, &tagline, stride, @intCast(tag.width), @intCast(tag.height), 0, @intCast(tag.width), tag.baseline));
const b = inkBounds(&body, @intCast(stride), @intCast(cell_w), @intCast(cell_h)).?;
const t = inkBounds(&tagline, @intCast(stride), @intCast(tag.width), @intCast(tag.height)).?;
try std.testing.expect(t.max_x - t.min_x < b.max_x - b.min_x);
@@ -361,11 +426,10 @@ test "tagline glyph shrinks into its own cell and stays vertically centered" {
test "tagline percentage changes measured band height without body metrics" {
const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
defer c.ui_font_free(font);
- const body_scale = c.ui_font_scale_for_height(font, 27.0);
var cell_w: c_int = 1;
var cell_h: c_int = 1;
var ascent: c_int = 1;
- c.ui_font_cell_metrics(font, body_scale, &cell_w, &cell_h, &ascent);
+ c.ui_font_cell_metrics(font, 27.0, &cell_w, &cell_h, &ascent);
const small = taglineRaster(font, 27.0, @intCast(cell_w), @intCast(cell_h), 40);
const configured = taglineRaster(font, 27.0, @intCast(cell_w), @intCast(cell_h), 82);
const full = taglineRaster(font, 27.0, @intCast(cell_w), @intCast(cell_h), 100);
@@ -375,18 +439,17 @@ test "tagline percentage changes measured band height without body metrics" {
try std.testing.expect(small.height < configured.height);
try std.testing.expect(configured.height <= full.height);
try std.testing.expect(full.height <= @as(u32, @intCast(cell_h)));
- try std.testing.expectEqual(body_scale, c.ui_font_scale_for_height(font, 27.0));
}
test "glyph atlas cache separates body and tagline roles" {
var glyphs = std.AutoHashMap(GlyphKey, Slot).init(std.testing.allocator);
defer glyphs.deinit();
- try glyphs.put(.{ .codepoint = 'A', .role = .body }, .{ .u = 0, .v = 0 });
- try glyphs.put(.{ .codepoint = 'A', .role = .tagline }, .{ .u = 10, .v = 0 });
- try glyphs.put(.{ .codepoint = 'A', .role = .body, .decoration = .{ .bold = true } }, .{ .u = 20, .v = 0 });
+ try glyphs.put(.{ .face = 0, .glyph = 36, .role = .body }, .{ .u = 0, .v = 0 });
+ try glyphs.put(.{ .face = 0, .glyph = 36, .role = .tagline }, .{ .u = 10, .v = 0 });
+ try glyphs.put(.{ .face = 0, .glyph = 36, .role = .body, .decoration = .{ .bold = true } }, .{ .u = 20, .v = 0 });
try std.testing.expectEqual(@as(usize, 3), glyphs.count());
- try std.testing.expectEqual(@as(u32, 0), glyphs.get(.{ .codepoint = 'A', .role = .body }).?.u);
- try std.testing.expectEqual(@as(u32, 10), glyphs.get(.{ .codepoint = 'A', .role = .tagline }).?.u);
+ try std.testing.expectEqual(@as(u32, 0), glyphs.get(.{ .face = 0, .glyph = 36, .role = .body }).?.u);
+ try std.testing.expectEqual(@as(u32, 10), glyphs.get(.{ .face = 0, .glyph = 36, .role = .tagline }).?.u);
}
test "installed Nerd Symbols fallback covers Yazi directory icons" {
@@ -402,7 +465,7 @@ test "installed Nerd Symbols fallback covers Yazi directory icons" {
defer std.testing.allocator.free(bytes);
const face = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit;
defer c.ui_font_free(face);
- try std.testing.expectEqual(@as(c_int, 1), c.ui_font_has_glyph(face, 0xe5ff));
+ try std.testing.expect(c.ui_font_glyph(face, 0xe5ff) != 0);
}
const CellInstance = extern struct {
@@ -432,6 +495,11 @@ const CellInstance = extern struct {
progress_bits: u32 = @bitCast(@as(f32, 1)),
serial: u32 = 0,
cell_coord: u32 = 0,
+ /// A clip rectangle in target pixels; x1 < x0 is none (ui.vert.glsl).
+ clip_x0: f32 = 0,
+ clip_y0: f32 = 0,
+ clip_x1: f32 = -1,
+ clip_y1: f32 = -1,
};
const OverlayVertex = extern struct {
@@ -473,6 +541,14 @@ const initial_image_capacity: u32 = pardes.MAX_PANES;
const old_layer_bit: u32 = 0x8000_0000;
const clear_bg_bit: u32 = 0x4000_0000;
const opaque_bg_bit: u32 = 0x2000_0000;
+/// Decor that is a soft shadow, not a flat fill (decor.frag.glsl).
+const soft_shadow_bit: u32 = 0x1000_0000;
+/// Decor that is a checker (decor.frag.glsl).
+const checker_bit: u32 = 0x0800_0000;
+/// A cell on the page's ground under the theme's dots, and a file name's
+/// cell that casts the theme's shadow (ui.frag.glsl, Chrome.decor_*).
+const dotted_bit: u32 = 0x1000_0000;
+const title_bit: u32 = 0x0800_0000;
const SavedImagePlace = struct {
key: pardes.ImageCacheKey,
@@ -509,8 +585,8 @@ const SavedImagePlace = struct {
const PreparedImage = struct {
place: SavedImagePlace,
texture: *c.SDL_GPUTexture,
- track: ?pardes.layout.Track = null,
- clip: ?pardes.layout.Box = null,
+ track: ?pardes.animation.Track = null,
+ clip: ?pardes.animation.Box = null,
old_layer: bool = false,
};
@@ -534,7 +610,8 @@ test "saved native placement retains identity and geometry but no producer bytes
}
test "shader instance ABI carries aligned transition vectors" {
- try std.testing.expectEqual(@as(usize, 104), @sizeOf(CellInstance));
+ try std.testing.expectEqual(@as(usize, 120), @sizeOf(CellInstance));
+ try std.testing.expectEqual(@as(usize, 104), @offsetOf(CellInstance, "clip_x0"));
try std.testing.expectEqual(@as(usize, 56), @offsetOf(CellInstance, "panel_x0"));
try std.testing.expectEqual(@as(usize, 72), @offsetOf(CellInstance, "present_x0"));
try std.testing.expectEqual(@as(usize, 88), @offsetOf(CellInstance, "effect"));
@@ -544,43 +621,52 @@ test "shader instance ABI carries aligned transition vectors" {
try std.testing.expectEqual(@as(usize, 64), @offsetOf(ImageInstance, "effect"));
try std.testing.expectEqual(@as(usize, 32), @sizeOf([8]f32));
- const tracks = [_]pardes.layout.Track{
+ const tracks = [_]pardes.animation.Track{
.{ .pane = 0, .phase = .opening, .effect = .slide },
.{ .pane = 1, .phase = .moving, .effect = .slide },
.{ .pane = 2, .phase = .moving, .effect = .slide },
};
- const plan = makePaintPlan(&tracks, true);
- try std.testing.expectEqual(@as(usize, 4), plan.len);
- try std.testing.expect(plan.batches[0].track == null);
- try std.testing.expectEqual(@as(u8, 1), plan.batches[1].track.?.pane);
- try std.testing.expectEqual(@as(u8, 2), plan.batches[2].track.?.pane);
- try std.testing.expectEqual(@as(u8, 0), plan.batches[3].track.?.pane);
+ // Tier 0, the tracks as the core ordered them, then tiers 4 and 5.
+ const groups = makeGroups(&tracks, true);
+ try std.testing.expectEqual(@as(usize, 7), groups.len);
+ try std.testing.expect(groups.items[0].track == null);
+ try std.testing.expectEqual(@as(u8, 0), groups.items[1].track.?.pane);
+ try std.testing.expectEqual(@as(u8, 1), groups.items[2].track.?.pane);
+ try std.testing.expectEqual(@as(u8, 2), groups.items[3].track.?.pane);
+ try std.testing.expectEqual(@as(usize, 4), groups.notices);
+ try std.testing.expectEqual(@as(usize, 5), groups.guides);
+ try std.testing.expectEqual(@as(usize, 6), groups.ink);
+ for ([_]usize{ groups.notices, groups.guides, groups.ink }) |index| try std.testing.expect(groups.items[index].track == null);
}
test "GUI paint plan snaps history effects without a frozen grid" {
- const tracks = [_]pardes.layout.Track{
+ const tracks = [_]pardes.animation.Track{
.{ .pane = 0, .phase = .opening, .effect = .ascii },
.{ .pane = 1, .phase = .closing, .effect = .vertical },
};
- try std.testing.expectEqual(@as(usize, 1), makePaintPlan(&tracks, false).len);
- const ready = makePaintPlan(&tracks, true);
- try std.testing.expectEqual(@as(usize, 3), ready.len);
- try std.testing.expectEqual(pardes.layout.Phase.opening, ready.batches[1].track.?.phase);
- try std.testing.expectEqual(pardes.layout.Phase.closing, ready.batches[2].track.?.phase);
+ try std.testing.expectEqual(@as(usize, 0), makeGroups(&tracks, false).tracks);
+ const ready = makeGroups(&tracks, true);
+ try std.testing.expectEqual(@as(usize, 2), ready.tracks);
+ try std.testing.expectEqual(pardes.animation.Phase.opening, ready.items[1].track.?.phase);
+ try std.testing.expectEqual(pardes.animation.Phase.closing, ready.items[2].track.?.phase);
}
test "closing tombstone overlays but never owns canonical cells" {
- const closing: pardes.layout.Track = .{
+ const closing: pardes.animation.Track = .{
.pane = 0,
.phase = .closing,
.effect = .vertical,
.from = .{ .x = 2, .y = 3, .w = 10, .h = 4 },
.to = .{ .x = 2, .y = -1, .w = 10, .h = 4 },
};
- const plan = makePaintPlan(&.{closing}, true);
- try std.testing.expectEqual(@as(usize, 0), paintBatchAt(&plan, 4, 4));
- try std.testing.expectEqual(@as(usize, 2), plan.len);
- try std.testing.expectEqual(pardes.layout.Phase.closing, plan.batches[1].track.?.phase);
+ const groups = makeGroups(&.{closing}, true);
+ try std.testing.expectEqual(@as(usize, 0), groupAt(&groups, 4, 4));
+ // A still pane's notice stays under the tombstone sliding over it.
+ const notice: pardes.Layer = .{ .kind = .notice, .viewport = .{ .x = 4, .y = 4, .w = 3, .h = 1 }, .rows = 1 };
+ try std.testing.expectEqual(@as(usize, 0), noticeGroup(&groups, &notice));
+ try std.testing.expectEqual(makeGroups(&.{}, false).notices, noticeGroup(&makeGroups(&.{}, false), &notice));
+ try std.testing.expectEqual(@as(usize, 1), groups.tracks);
+ try std.testing.expectEqual(pardes.animation.Phase.closing, groups.items[1].track.?.phase);
}
fn updateCoreResize(core: *pardes.Pardes, cols: u16, rows: u16, cell_w: u32, cell_h: u32, tag_w: u32, tag_h: u32) bool {
@@ -780,288 +866,37 @@ fn emitTouchClick(t: *Touch, in: *Input, point: TouchNormPoint, button: pardes.M
in.post(.{ .mouse = .{ .button = button, .kind = .release, .col = cell.col, .row = cell.row, .tag_hit = cell.tag_hit, .body_hit = cell.body_hit } });
}
-fn normCell(norm: f32, win: f32, cell: f32) u16 {
- const px = std.math.clamp(norm, 0.0, 1.0) * win;
- return @intFromFloat(@max(0, @floor(px / cell)));
-}
-
const Pty = struct {
fd: c_int,
pid: libc.pid_t,
serial: u32,
kill_at: i64 = 0,
- reader: ?std.Thread = null,
- stop: [2]c_int = .{ -1, -1 },
+ /// Its reader, blocked in an Io read: `closePty` cancels it.
+ reader: ?std.Io.Future(void) = null,
+ /// A command pane's child, watched to its exit (host_io.watchExit);
+ /// the pty stays open until both its end of file and its exit.
+ cmd: host_io.CommandWatch = .{},
};
-const RetiredShell = struct { pid: libc.pid_t = 0, kill_at: i64 = 0 };
-
-const Msg = union(enum) {
- output: struct { pane: u8, gen: u32, bytes: []u8 },
- eof: struct { pane: u8, gen: u32, failure: ?anyerror = null },
- lsp: struct { id: u32, rows: ?[]u8 },
- lsp_status: []u8,
- pipe: selection_pipe.Response,
- files_changed,
- fs_ready,
- fn deinit(m: Msg, gpa: std.mem.Allocator, lsp_allocator: std.mem.Allocator) void {
- switch (m) {
- .output => |o| gpa.free(o.bytes),
- .lsp => |l| if (l.rows) |rows| lsp_allocator.free(rows),
- .lsp_status => |t| lsp_allocator.free(t),
- .pipe => |response_value| {
- var response = response_value;
- response.deinit(gpa);
- },
- .eof, .files_changed, .fs_ready => {},
- }
- }
-};
-
-const LspWorkers = struct {
- const capacity = 16;
- active: std.atomic.Value(usize) = .init(0),
-
- fn start(workers: *LspWorkers) bool {
- var count = workers.active.load(.monotonic);
- while (count < capacity)
- count = workers.active.cmpxchgWeak(count, count + 1, .monotonic, .monotonic) orelse return true;
- return false;
- }
+const RetiredShell = struct { pid: libc.pid_t = 0, kill_at: i64 = 0 };
- fn finish(workers: *LspWorkers) void {
- const previous = workers.active.fetchSub(1, .release);
- std.debug.assert(previous > 0);
- }
-
- fn wait(workers: *LspWorkers) void {
- var spins: u8 = 0;
- while (workers.active.load(.acquire) != 0) {
- spins +%= 1;
- if (spins == 0) std.Thread.yield() catch {} else std.atomic.spinLoopHint();
- }
- }
-};
+const Queue = host_io.Inbox;
+/// Wakes a blocking SDL_WaitEventTimeout after a push from another thread.
+fn sdlWake(_: ?*anyopaque) void {
+ var sev = std.mem.zeroes(c.SDL_Event);
+ sev.type = c.SDL_EVENT_USER;
+ _ = c.SDL_PushEvent(&sev);
+}
+const Msg = Queue.Msg;
+const MessageBatch = Queue.Batch;
const PipeTasks = selection_pipe.Tasks;
-
-const queue_capacity = 512;
-const output_capacity = queue_capacity - pardes.MAX_PANES;
-
-const MessageBatch = struct {
- items: [queue_capacity + PipeTasks.capacity + 2]Msg = undefined,
- len: usize = 0,
-
- fn slice(batch: *MessageBatch) []Msg {
- return batch.items[0..batch.len];
- }
-};
-
-const Queue = struct {
- gpa: std.mem.Allocator,
- lsp_allocator: std.mem.Allocator,
- lsp_workers: *LspWorkers,
- sdl_wake: bool, // wake a blocking SDL_WaitEventTimeout on cross-thread push
- mutex: libc.pthread_mutex_t = .{},
- space: libc.pthread_cond_t = .{},
- items: [queue_capacity]Msg = undefined,
- head: usize = 0,
- len: usize = 0,
- closed: bool = false,
- files_changed: bool = false,
- readers: [pardes.MAX_PANES]?u32 = @splat(null),
- waiting: usize = 0,
- lsp_id: ?u32 = null,
- completions: [PipeTasks.capacity + 1]Msg = undefined,
- completion_len: usize = 0,
-
- fn lock(q: *Queue) void {
- std.debug.assert(libc.pthread_mutex_lock(&q.mutex) == .SUCCESS);
- }
-
- fn unlock(q: *Queue) void {
- std.debug.assert(libc.pthread_mutex_unlock(&q.mutex) == .SUCCESS);
- }
-
- fn wake(q: *Queue) void {
- if (q.sdl_wake) {
- var sev = std.mem.zeroes(c.SDL_Event);
- sev.type = c.SDL_EVENT_USER;
- _ = c.SDL_PushEvent(&sev);
- }
- }
-
- fn acceptReader(q: *Queue, pane: u8, gen: u32) void {
- q.lock();
- defer q.unlock();
- std.debug.assert(q.readers[pane] == null);
- q.readers[pane] = gen;
- }
-
- fn cancelReader(q: *Queue, pane: u8, gen: u32) void {
- q.lock();
- defer q.unlock();
- if (q.readers[pane] != gen) return;
- q.readers[pane] = null;
- var i: usize = 0;
- while (i < q.len) {
- const msg = q.items[(q.head + i) % q.items.len];
- const matches = switch (msg) {
- .output => |o| o.pane == pane and o.gen == gen,
- .eof => |e| e.pane == pane and e.gen == gen,
- else => false,
- };
- if (matches) q.removeAt(i).deinit(q.gpa, q.lsp_allocator) else i += 1;
- }
- std.debug.assert(libc.pthread_cond_broadcast(&q.space) == .SUCCESS);
- }
-
- fn pushOutput(q: *Queue, pane: u8, gen: u32, bytes: []u8) bool {
- q.lock();
- while (!q.closed and q.readers[pane] == gen and q.len >= output_capacity) {
- q.waiting += 1;
- std.debug.assert(libc.pthread_cond_wait(&q.space, &q.mutex) == .SUCCESS);
- q.waiting -= 1;
- }
- if (q.closed or q.readers[pane] != gen) {
- q.unlock();
- q.gpa.free(bytes);
- return false;
- }
- q.items[(q.head + q.len) % q.items.len] = .{ .output = .{ .pane = pane, .gen = gen, .bytes = bytes } };
- q.len += 1;
- q.unlock();
- q.wake();
- return true;
- }
-
- fn removeAt(q: *Queue, offset: usize) Msg {
- const removed = q.items[(q.head + offset) % q.items.len];
- var i = offset;
- while (i + 1 < q.len) : (i += 1)
- q.items[(q.head + i) % q.items.len] = q.items[(q.head + i + 1) % q.items.len];
- q.len -= 1;
- return removed;
- }
-
- fn discardLsp(q: *Queue) void {
- for (q.completions[0..q.completion_len], 0..) |msg, i| if (msg == .lsp) {
- msg.deinit(q.gpa, q.lsp_allocator);
- q.completion_len -= 1;
- std.mem.copyForwards(Msg, q.completions[i..q.completion_len], q.completions[i + 1 .. q.completion_len + 1]);
- return;
- };
- }
-
- fn push(q: *Queue, m: Msg) void {
- if (m == .output) {
- _ = q.pushOutput(m.output.pane, m.output.gen, m.output.bytes);
- return;
- }
- q.lock();
- if (q.closed) {
- q.unlock();
- m.deinit(q.gpa, q.lsp_allocator);
- return;
- }
- switch (m) {
- .files_changed => q.files_changed = true,
- .lsp, .pipe => {
- if (m == .lsp) {
- if (q.lsp_id != m.lsp.id) {
- q.unlock();
- m.deinit(q.gpa, q.lsp_allocator);
- return;
- }
- q.discardLsp();
- }
- std.debug.assert(q.completion_len < q.completions.len);
- q.completions[q.completion_len] = m;
- q.completion_len += 1;
- },
- else => {
- if (m == .eof) {
- if (q.readers[m.eof.pane] != m.eof.gen) {
- q.unlock();
- return;
- }
- std.debug.assert(q.len < q.items.len);
- } else if (q.len >= output_capacity) {
- q.unlock();
- m.deinit(q.gpa, q.lsp_allocator);
- return;
- }
- q.items[(q.head + q.len) % q.items.len] = m;
- q.len += 1;
- },
- }
- q.unlock();
- q.wake();
- }
-
- fn take(q: *Queue) MessageBatch {
- q.lock();
- defer q.unlock();
- var batch: MessageBatch = .{};
- while (q.len > 0) {
- batch.items[batch.len] = q.items[q.head];
- batch.len += 1;
- q.head = (q.head + 1) % q.items.len;
- q.len -= 1;
- }
- q.head = 0;
- if (q.files_changed) {
- batch.items[batch.len] = .files_changed;
- batch.len += 1;
- q.files_changed = false;
- }
- @memcpy(batch.items[batch.len..][0..q.completion_len], q.completions[0..q.completion_len]);
- batch.len += q.completion_len;
- q.completion_len = 0;
- std.debug.assert(libc.pthread_cond_broadcast(&q.space) == .SUCCESS);
- return batch;
- }
-
- fn discardCompletions(q: *Queue) void {
- q.lock();
- defer q.unlock();
- q.lsp_id = null;
- for (q.completions[0..q.completion_len]) |msg| msg.deinit(q.gpa, q.lsp_allocator);
- q.completion_len = 0;
- }
-
- fn close(q: *Queue) void {
- q.lock();
- q.closed = true;
- q.files_changed = false;
- q.readers = @splat(null);
- std.debug.assert(libc.pthread_cond_broadcast(&q.space) == .SUCCESS);
- q.unlock();
- q.discardCompletions();
- q.lock();
- defer q.unlock();
- while (q.len > 0) {
- const m = q.items[q.head];
- m.deinit(q.gpa, q.lsp_allocator);
- q.head = (q.head + 1) % q.items.len;
- q.len -= 1;
- }
- q.head = 0;
- }
-
- fn deinit(q: *Queue) void {
- q.close();
- std.debug.assert(q.waiting == 0);
- std.debug.assert(libc.pthread_cond_destroy(&q.space) == .SUCCESS);
- std.debug.assert(libc.pthread_mutex_destroy(&q.mutex) == .SUCCESS);
- }
-};
+const output_capacity = Queue.output_capacity;
test "GUI completion survives a full output queue" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = 7 };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .lsp_id = 7 };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{
@@ -1099,8 +934,8 @@ test "GUI completion survives a full output queue" {
const PtyTests = struct {
fn waitBlocked(queue: *Queue) !void {
- const until = shellClock() + 2_000;
- while (shellClock() < until) {
+ const until = std.Io.Clock.awake.now(std.testing.io).toMilliseconds() + 2_000;
+ while (std.Io.Clock.awake.now(std.testing.io).toMilliseconds() < until) {
queue.lock();
const waiting = queue.waiting;
queue.unlock();
@@ -1117,8 +952,7 @@ const PtyTests = struct {
test "GUI PTY backpressure retains byte order and tail before EOF" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "before") } });
@@ -1152,8 +986,7 @@ test "GUI PTY backpressure retains byte order and tail before EOF" {
test "GUI PTY backpressure cancellation and close release owned producers" {
const gpa = std.testing.allocator;
for ([_]bool{ false, true }) |close| {
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "before") } });
@@ -1184,15 +1017,14 @@ test "GUI PTY backpressure cancellation and close release owned producers" {
test "GUI PTY EOF reserve cannot evict terminal output" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
for (0..pardes.MAX_PANES) |pane| queue.acceptReader(@intCast(pane), 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "before") } });
for (0..pardes.MAX_PANES) |pane| queue.push(.{ .eof = .{ .pane = @intCast(pane), .gen = 1 } });
var batch = queue.take();
defer for (batch.slice()) |msg| msg.deinit(gpa, gpa);
- try std.testing.expectEqual(queue_capacity, batch.len);
+ try std.testing.expectEqual(Queue.capacity, batch.len);
for (batch.items[0..output_capacity]) |msg| try std.testing.expectEqualStrings("before", msg.output.bytes);
for (batch.items[output_capacity..batch.len], 0..) |msg, pane| try std.testing.expectEqual(pane, msg.eof.pane);
}
@@ -1201,8 +1033,7 @@ test "GUI PTY reader delivers a real shell tail before EOF and joins on close" {
const gpa = std.testing.allocator;
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(1);
@@ -1217,13 +1048,13 @@ test "GUI PTY reader delivers a real shell tail before EOF and joins on close" {
const rcs: host_io.Shell.PromptFiles = .{};
const child = try host_io.forkShell(null, 0, &rcs, "/bin/sh", "", 24, 80, null);
ptys[0] = .{ .fd = child.file.handle, .pid = child.pid, .serial = core.panes[0].?.serial };
- try spawnReader(gpa, &ptys[0].?, 0, 1, &queue);
+ ptys[0].?.reader = try queue.startReader(.{ .handle = ptys[0].?.fd, .flags = .{ .nonblocking = false } }, 0, 1);
try std.testing.expect(host_io.writeFd(child.file.handle, "printf '\\120\\101\\122\\104\\105\\123\\055\\124\\101\\111\\114'; exit\n"));
var bytes: std.ArrayList(u8) = .empty;
defer bytes.deinit(gpa);
var eof = false;
- const until = shellClock() + 2_000;
- while (!eof and shellClock() < until) {
+ const until = std.Io.Clock.awake.now(std.testing.io).toMilliseconds() + 2_000;
+ while (!eof and std.Io.Clock.awake.now(std.testing.io).toMilliseconds() < until) {
var batch = queue.take();
defer for (batch.slice()) |msg| msg.deinit(gpa, gpa);
for (batch.slice()) |msg| switch (msg) {
@@ -1251,9 +1082,8 @@ test "GUI PTY Restore joins a real reader waiting for queue space" {
const gpa = std.testing.allocator;
var core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- try core.dumpState();
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ try dump.dumpState(core);
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
queue.acceptReader(1, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{ .pane = 1, .gen = 1, .bytes = try gpa.dupe(u8, "other pane") } });
@@ -1270,11 +1100,11 @@ test "GUI PTY Restore joins a real reader waiting for queue space" {
const rcs: host_io.Shell.PromptFiles = .{};
const child = try host_io.forkShell(null, 0, &rcs, "/bin/sh", "", 24, 80, null);
ptys[0] = .{ .fd = child.file.handle, .pid = child.pid, .serial = core.panes[0].?.serial };
- try spawnReader(gpa, &ptys[0].?, 0, 1, &queue);
+ ptys[0].?.reader = try queue.startReader(.{ .handle = ptys[0].?.fd, .flags = .{ .nonblocking = false } }, 0, 1);
try std.testing.expect(host_io.writeFd(child.file.handle, "printf 'after-full'; exit\n"));
try PtyTests.waitBlocked(&queue);
const old_serial = core.panes[0].?.serial;
- const replacement = try core.restore(core.dump_out.?);
+ const replacement = try dump.restore(core, core.dump_out.?, "test");
shell.stopPtys();
core.deinit();
core = replacement;
@@ -1297,8 +1127,7 @@ test "GUI PTY deletion joins an idle reader and retains only its owned child for
const gpa = std.testing.allocator;
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(1);
@@ -1313,8 +1142,8 @@ test "GUI PTY deletion joins an idle reader and retains only its owned child for
const rcs: host_io.Shell.PromptFiles = .{};
const child = try host_io.forkShell(null, 0, &rcs, "/bin/sh", "", 24, 80, null);
ptys[0] = .{ .fd = child.file.handle, .pid = child.pid, .serial = core.panes[0].?.serial };
- try spawnReader(gpa, &ptys[0].?, 0, 1, &queue);
- try core.removePane(0);
+ ptys[0].?.reader = try queue.startReader(.{ .handle = ptys[0].?.fd, .flags = .{ .nonblocking = false } }, 0, 1);
+ try core.removePane(0, null);
shell.reconcilePtys();
try std.testing.expect(queue.readers[0] == null);
try std.testing.expectEqual(@as(usize, 0), queue.waiting);
@@ -1329,8 +1158,7 @@ test "GUI PTY deletion joins an idle reader and retains only its owned child for
test "GUI PTY file watcher stops and joins without closing its watched descriptor" {
if (!file_watch.supported) return error.SkipZigTest;
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
const fd = file_watch.init(true);
if (fd < 0) return error.WatchInitFailed;
@@ -1351,11 +1179,10 @@ test "GUI completion failure survives backlog and leaves the document unchanged"
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
const pane = try core.setTestFile("abc");
- pane.cur_col = 1;
+ pane.body.cur_col = 1;
core.lspRequest(core.active, .completion, "");
const id = core.lsp_wait.?.id;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = id };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .lsp_id = id };
defer queue.deinit();
queue.acceptReader(0, 1);
for (0..output_capacity) |_| queue.push(.{ .output = .{
@@ -1378,14 +1205,13 @@ test "GUI completion failure survives backlog and leaves the document unchanged"
shell.drainQueue();
try std.testing.expect(core.lsp_wait == null);
try std.testing.expectEqualStrings("abc", pane.file.?.content);
- try std.testing.expectEqual(@as(i32, 1), pane.cur_col);
+ try std.testing.expectEqual(@as(i32, 1), pane.body.cur_col);
try std.testing.expect(shell.saw_event);
}
test "GUI completions retain their arrival order across LSP and pipes" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = 2 };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .lsp_id = 2 };
defer queue.deinit();
queue.push(.{ .pipe = .{ .id = 1, .success = true, .outputs = &.{} } });
queue.push(.{ .lsp = .{ .id = 2, .rows = try gpa.dupe(u8, "second") } });
@@ -1401,8 +1227,7 @@ test "GUI completions retain their arrival order across LSP and pipes" {
test "GUI completion reset frees queued payloads and rejects late LSP workers" {
const gpa = std.testing.allocator;
- var workers: LspWorkers = .{};
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = gpa, .lsp_workers = &workers, .sdl_wake = false, .lsp_id = 9 };
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa, .lsp_id = 9 };
defer queue.deinit();
queue.acceptReader(0, 1);
queue.push(.{ .output = .{ .pane = 0, .gen = 1, .bytes = try gpa.dupe(u8, "retained") } });
@@ -1449,42 +1274,7 @@ test "GUI completion reset frees queued payloads and rejects late LSP workers" {
try std.testing.expectEqual(@as(usize, 0), queue.take().len);
}
-fn lspStatusSink(ctx: ?*anyopaque, text: []const u8) void {
- const q: *Queue = @ptrCast(@alignCast(ctx orelse return));
- const copy = q.lsp_allocator.dupe(u8, text) catch return;
- q.push(.{ .lsp_status = copy });
-}
-fn readPtyThread(gpa: std.mem.Allocator, fd: c_int, stop: c_int, pane: u8, gen: u32, q: *Queue) void {
- var buf: [0x10000]u8 = undefined;
- var failure: ?anyerror = null;
- while (true) {
- var fds = [_]libc.pollfd{
- .{ .fd = stop, .events = libc.POLL.IN, .revents = 0 },
- .{ .fd = fd, .events = libc.POLL.IN, .revents = 0 },
- };
- if (libc.poll(&fds, fds.len, -1) < 0) {
- if (libc.errno(-1) == .INTR) continue;
- failure = error.PollFailed;
- break;
- }
- if (fds[0].revents != 0) return;
- if (fds[1].revents == 0) continue;
- const n = libc.read(fd, &buf, buf.len);
- if (n < 0) {
- if (libc.errno(n) == .INTR) continue;
- if (libc.errno(n) != .IO) failure = error.ReadFailed;
- break;
- }
- if (n == 0) break;
- const bytes = gpa.dupe(u8, buf[0..@intCast(n)]) catch |err| {
- failure = err;
- break;
- };
- if (!q.pushOutput(pane, gen, bytes)) return;
- }
- q.push(.{ .eof = .{ .pane = pane, .gen = gen, .failure = failure } });
-}
fn stopPipe() ![2]c_int {
var fds: [2]c_int = undefined;
@@ -1496,17 +1286,6 @@ fn stopPipe() ![2]c_int {
return fds;
}
-fn spawnReader(gpa: std.mem.Allocator, pt: *Pty, pane: u8, gen: u32, q: *Queue) !void {
- std.debug.assert(pt.reader == null and pt.fd >= 0);
- const stop = try stopPipe();
- errdefer for (stop) |fd| {
- _ = libc.close(fd);
- };
- q.acceptReader(pane, gen);
- errdefer q.cancelReader(pane, gen);
- pt.reader = try std.Thread.spawn(.{}, readPtyThread, .{ gpa, pt.fd, stop[0], pane, gen, q });
- pt.stop = stop;
-}
fn watchThread(fd: c_int, stop: c_int, q: *Queue) void {
while (true) {
@@ -1524,149 +1303,32 @@ fn watchThread(fd: c_int, stop: c_int, q: *Queue) void {
}
}
-fn lspThread(lsp_allocator: std.mem.Allocator, workers: *LspWorkers, job: *host_io.Lsp.Job, q: *Queue) void {
- defer workers.finish();
- host_io.Lsp.work(lsp_allocator, job, q, pushLspRows);
-}
-fn pushLspRows(ctx: ?*anyopaque, id: u32, rows: ?[]u8) void {
- const q: *Queue = @ptrCast(@alignCast(ctx orelse return));
- q.push(.{ .lsp = .{ .id = id, .rows = rows } });
-}
-fn spawnLsp(core: *pardes.Pardes, q: *Queue, e: host_io.Lsp.Request) void {
- const lsp_allocator = q.lsp_allocator;
- q.lock();
- q.lsp_id = e.id;
- q.discardLsp();
- q.unlock();
- if (!q.lsp_workers.start()) {
- core.update(.{ .lsp_resp = .{ .id = e.id, .rows = null } });
- return core.reportError(e.pane, "lsp", error.WorkersBusy);
- }
- const job = host_io.Lsp.snapshot(lsp_allocator, core, e) catch |err| {
- q.lsp_workers.finish();
- core.update(.{ .lsp_resp = .{ .id = e.id, .rows = null } });
- return core.reportError(e.pane, "lsp", err);
- };
- const th = std.Thread.spawn(.{}, lspThread, .{ lsp_allocator, q.lsp_workers, job, q }) catch |err| {
- q.lsp_workers.finish();
- job.free(lsp_allocator);
- core.update(.{ .lsp_resp = .{ .id = e.id, .rows = null } });
- return core.reportError(e.pane, "lsp", err);
- };
- th.detach();
-}
-
-test "GUI LSP worker limit rejects before allocation and recovers after owned workers exit" {
+test "GUI LSP query answers, and a newer one cancels it" {
const gpa = std.testing.allocator;
+ const io = std.testing.io;
const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
defer core.deinit();
- const pane = try core.setTestFile("abc");
- pane.cur_col = 1;
- var workers: LspWorkers = .{};
- var gate: std.Io.Event = .unset;
- var threads: [LspWorkers.capacity]?std.Thread = @splat(null);
- defer {
- gate.set(std.testing.io);
- for (threads) |thread| if (thread) |owned| owned.join();
- workers.wait();
- }
- for (&threads) |*thread| {
- try std.testing.expect(workers.start());
- thread.* = std.Thread.spawn(.{}, struct {
- fn run(active: *LspWorkers, ready: *std.Io.Event) void {
- defer active.finish();
- ready.waitUncancelable(std.testing.io);
- }
- }.run, .{ &workers, &gate }) catch |err| {
- workers.finish();
- return err;
- };
- }
- try std.testing.expectEqual(@as(usize, LspWorkers.capacity), workers.active.load(.monotonic));
- try std.testing.expect(!workers.start());
- var failing = std.testing.FailingAllocator.init(gpa, .{ .fail_index = 0 });
- var queue: Queue = .{ .gpa = gpa, .lsp_allocator = failing.allocator(), .lsp_workers = &workers, .sdl_wake = false };
+ _ = try core.setTestFile("abc");
+ var queue: Queue = .{ .io = std.testing.io, .gpa = gpa, .lsp_allocator = gpa };
defer queue.deinit();
- core.lspRequest(core.active, .completion, "");
- const rejected = core.lsp_wait.?.id;
- queue.lsp_id = rejected -% 1;
- queue.push(.{ .lsp = .{ .id = queue.lsp_id.?, .rows = try gpa.dupe(u8, "obsolete queued result") } });
- spawnLsp(core, &queue, .{
- .id = rejected,
- .kind = .completion,
- .pane = @intCast(core.active),
- .offset = 1,
- .arg = "",
- });
- try std.testing.expect(core.lsp_wait == null);
- try std.testing.expectEqualStrings("abc", pane.file.?.content);
- try std.testing.expectEqual(@as(i32, 1), pane.cur_col);
- try std.testing.expect(std.mem.indexOf(u8, pane.msg[0..pane.msg_len], "WorkersBusy") != null);
- try std.testing.expectEqual(@as(usize, 0), failing.alloc_index);
- try std.testing.expect(!failing.has_induced_failure);
- try std.testing.expectEqual(rejected, queue.lsp_id.?);
- try std.testing.expectEqual(@as(usize, 0), queue.completion_len);
- queue.push(.{ .lsp = .{ .id = rejected -% 1, .rows = try gpa.dupe(u8, "obsolete late result") } });
- try std.testing.expectEqual(@as(usize, 0), queue.completion_len);
- try std.testing.expectEqual(@as(usize, LspWorkers.capacity), workers.active.load(.monotonic));
-
- gate.set(std.testing.io);
- workers.wait();
- try std.testing.expectEqual(@as(usize, 0), workers.active.load(.monotonic));
- queue.lsp_allocator = gpa;
- core.lspRequest(core.active, .status, "");
- const accepted = core.lsp_wait.?.id;
- spawnLsp(core, &queue, .{
- .id = accepted,
- .kind = .status,
- .pane = @intCast(core.active),
- .offset = 0,
- .arg = "",
- });
- workers.wait();
+ for (0..2) |_| {
+ core.lspRequest(core.active, .status, "");
+ queue.startLsp(core, .{ .id = core.lsp_wait.?.id, .kind = .status, .pane = @intCast(core.active), .offset = 0, .arg = "" });
+ }
+ const last = core.lsp_wait.?.id;
+ queue.lsp_task.?.future.await(io);
+ queue.lsp_task = null;
var batch = queue.take();
defer for (batch.slice()) |msg| msg.deinit(gpa, gpa);
try std.testing.expectEqual(@as(usize, 1), batch.len);
- try std.testing.expectEqual(accepted, batch.items[0].lsp.id);
+ try std.testing.expectEqual(last, batch.items[0].lsp.id);
try std.testing.expect(batch.items[0].lsp.rows != null);
- core.update(.{ .lsp_resp = .{ .id = accepted, .rows = batch.items[0].lsp.rows } });
+ core.update(.{ .lsp_resp = .{ .id = last, .rows = batch.items[0].lsp.rows } });
try std.testing.expect(core.lsp_wait == null);
- try std.testing.expectEqual(@as(usize, 0), workers.active.load(.monotonic));
- try std.testing.expectEqualStrings("abc", pane.file.?.content);
}
-fn pipeThread(io: std.Io, gpa: std.mem.Allocator, job: *selection_pipe.Job, q: *Queue) anyerror!void {
- defer job.deinit(gpa);
- const response = selection_pipe.runJob(gpa, io, job);
- q.push(.{ .pipe = response });
-}
-
-fn spawnPipe(
- core: *pardes.Pardes,
- io: std.Io,
- gpa: std.mem.Allocator,
- q: *Queue,
- tasks: *PipeTasks,
- id: u32,
-) void {
- if (tasks.len == tasks.items.len) {
- core.update(.{ .pipe_resp = .{ .id = id, .success = false, .outputs = &.{} } });
- return;
- }
- const view = core.pipeRequest(id) orelse return;
- const job = selection_pipe.Job.copy(gpa, view) catch |err| {
- core.update(.{ .pipe_resp = .{ .id = id, .success = false, .outputs = &.{} } });
- return core.reportError(core.active, "pipe", err);
- };
- const future = io.concurrent(pipeThread, .{ io, gpa, job, q }) catch |err| {
- job.deinit(gpa);
- core.update(.{ .pipe_resp = .{ .id = id, .success = false, .outputs = &.{} } });
- return core.reportError(core.active, "pipe", err);
- };
- std.debug.assert(tasks.add(.{ .id = id, .future = future }));
-}
test "GUI worker setup failures finish matching LSP and pipe requests" {
const gpa = std.testing.allocator;
@@ -1680,12 +1342,10 @@ test "GUI worker setup failures finish matching LSP and pipe requests" {
var failing = std.testing.FailingAllocator.init(gpa, .{
.fail_index = if (failure == 0) 0 else std.math.maxInt(usize),
});
- var workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = std.testing.io,
.gpa = gpa,
.lsp_allocator = failing.allocator(),
- .lsp_workers = &workers,
- .sdl_wake = false,
};
defer queue.deinit();
var tasks: PipeTasks = .{};
@@ -1700,7 +1360,7 @@ test "GUI worker setup failures finish matching LSP and pipe requests" {
if (failure == 0) {
queue.lsp_id = req.id -% 1;
queue.push(.{ .lsp = .{ .id = queue.lsp_id.?, .rows = try gpa.dupe(u8, "old queued result") } });
- spawnLsp(core, &queue, req);
+ queue.startLsp(core, req);
try std.testing.expectEqual(req.id, queue.lsp_id.?);
try std.testing.expectEqual(@as(usize, 0), queue.completion_len);
queue.push(.{ .lsp = .{ .id = req.id -% 1, .rows = try gpa.dupe(u8, "late old result") } });
@@ -1714,16 +1374,16 @@ test "GUI worker setup failures finish matching LSP and pipe requests" {
try std.testing.expect(core.lsp_wait == null);
try std.testing.expectEqualStrings("abc", pane.file.?.content);
- pane.cur_col = 2;
- pane.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
+ pane.body.cur_col = 2;
+ pane.body.vsel = .{ .active = true, .row = 0, .col = 0, .explicit = true };
core.update(.{ .key = .{ .cp = '|' } });
core.update(.{ .key = .{ .cp = 't', .text = "tr a-z A-Z" } });
core.update(.{ .key = .{ .cp = pardes.Key.enter } });
- const pipe_id = core.pipe_wait.?.id;
- spawnPipe(core, failing_io, failing.allocator(), &queue, &tasks, pipe_id);
- try std.testing.expect(core.pipe_wait == null);
+ const pipe_id = core.pipe.wait.?.id;
+ selection_pipe.start(failing_io, failing.allocator(), core, &tasks, pipe_id, &queue, Queue.pushPipe);
+ try std.testing.expect(core.pipe.wait == null);
try std.testing.expectEqualStrings("abc", pane.file.?.content);
- try std.testing.expectEqual(@as(usize, 0), workers.active.load(.monotonic));
+ try std.testing.expect(queue.lsp_task == null);
try std.testing.expectEqual(@as(usize, 0), tasks.len);
try std.testing.expectEqual(@as(usize, 0), queue.len);
}
@@ -1734,9 +1394,13 @@ const Gui = struct {
device: *c.SDL_GPUDevice,
swapchain_format: c.SDL_GPUTextureFormat,
pipeline: *c.SDL_GPUGraphicsPipeline,
+ /// The cell pipeline, blending premultiplied over what is drawn under:
+ /// for a frame with a theme's tag plaques, whose blank tag cells let
+ /// them show (tagPlaques).
+ pipeline_over: *c.SDL_GPUGraphicsPipeline,
+ decor_pipeline: *c.SDL_GPUGraphicsPipeline,
overlay_pipeline: *c.SDL_GPUGraphicsPipeline,
image_pipeline: *c.SDL_GPUGraphicsPipeline,
- crt_pipeline: *c.SDL_GPUGraphicsPipeline,
atlas_tex: *c.SDL_GPUTexture,
atlas_sampler: *c.SDL_GPUSampler,
linear_sampler: *c.SDL_GPUSampler,
@@ -1753,6 +1417,11 @@ const Gui = struct {
native_images: std.AutoHashMapUnmanaged(pardes.ImageCacheKey, *c.SDL_GPUTexture) = .empty,
presented_images: std.ArrayListUnmanaged(SavedImagePlace) = .empty,
prepared_images: std.ArrayListUnmanaged(PreparedImage) = .empty,
+ /// renderFrame's cover of the grid (coverFrame): this frame's, then the
+ /// frame a panel transition is leaving.
+ cover: std.ArrayListUnmanaged(Cover) = .empty,
+ /// renderFrame's decor instances, group by group (buildDecor).
+ decor: std.ArrayListUnmanaged(CellInstance) = .empty,
font: *c.UIFont,
font_bytes: []u8 = &.{},
@@ -1761,13 +1430,12 @@ const Gui = struct {
fallbacks: [max_fallback_fonts]?LoadedFallback = @splat(null),
fallback_count: usize = 0,
px: f32,
- scale: f32,
- tagline_scale: f32,
+ tagline_px: f32,
tagline_percent: u8,
tagline_width: u32,
tagline_height: u32,
- attached_layers: ?*const [pardes.MAX_PANES]pardes.BodyLayer = null,
- attached_tag_layers: ?*const [pardes.MAX_TAG_LAYERS]pardes.TagLayer = null,
+ attached_layers: ?*const [pardes.MAX_PANES]pardes.Layer = null,
+ attached_tag_layers: ?*const [pardes.MAX_TAG_LAYERS]pardes.Layer = null,
cell_w: u32,
cell_h: u32,
ascent: i32,
@@ -1777,8 +1445,12 @@ const Gui = struct {
glyphs: std.AutoHashMap(GlyphKey, Slot),
pen_x: u32 = 0,
pen_y: u32 = 0,
- atlas_dirty: bool = true,
+ /// The atlas rows drawn into since the last upload, [top, bottom): the
+ /// whole atlas at first, since the texture starts undefined.
+ atlas_dirty_top: u32 = 0,
+ atlas_dirty_bottom: u32 = atlas_h,
space_slot: Slot = .{ .u = 0, .v = 0 },
+ words: Words = .{},
touch: Touch = .{},
pet_state: pet.State = .{},
@@ -1788,28 +1460,68 @@ const Gui = struct {
scroll_pane: ?usize = null,
scroll_rect: pardes.Rect = .{ .x = 0, .y = 0, .w = 0, .h = 0 },
scroll_body_y: u16 = 0, // that rect's first BODY row (Tagbottom moves it)
+ scroll_body_h: u16 = 0, // and its BODY rows, which a taller tag leaves fewer of
+ scroll_held_px: f32 = 0, // its tree-sitter context band, which never moves
scroll_col: u16 = 0, // where the wheel turned: crossed rows are delivered
scroll_row: u16 = 0, // THERE, not wherever the pointer has drifted to since
scroll_delta: f32 = 0, // finite raw distance waiting for the render batch
scroll_lag: f32 = 0, // picture position - core position, in rows
scroll_edge: []pardes.Cell = &.{}, // the row that just left the pane
scroll_edge_len: u16 = 0,
-
+ /// G6: a wheel's notches, whole lines, scroll the core at once and the
+ /// picture follows on a spring (Glide), never the other way round.
+ scroll_notch: i32 = 0,
+ /// A touchpad's fraction toward the next turn sent to a program that
+ /// owns the wheel (terminal.ownsWheel).
+ program_wheel: f32 = 0,
+ glide: Glide = .{},
+ /// PARDES_FRAMES_DEMO: the timedemo (FrameStats.named), its next step
+ /// and when it started; null when none runs.
+ demo: []const pardes.FrameStats.Step = &.{},
+ demo_name: []const u8 = "",
+ demo_next: ?usize = null,
+ demo_start_ns: u64 = 0,
+ /// The tick the last paced frame was sampled at (waitInput), and
+ /// whether this loop's wait read an input (drawn at once, not paced).
+ pace_ns: u64 = 0,
+ input_seen: bool = false,
+ /// G9 and G11: the selection's and the hovered word's glow blocks as
+ /// last drawn, for their fade-in.
+ sel_glow: SelGlow = .{},
+ hover_glow: SelGlow = .{},
+ /// G14: the cells last drawn and when each last changed.
+ /// The cursor's blink (blinkNow): when the frame drawn last arrived,
+ /// a redraw owed for an edge, and this frame's cursor mode and alpha.
+ frame_arrival_ns: u64 = 0,
+ blink_due: bool = false,
+ no_blink: bool = false,
+ cursor_quad_alpha: f32 = 0,
scene_tex: ?*c.SDL_GPUTexture = null,
scene_tex_w: u32 = 0,
scene_tex_h: u32 = 0,
scene_failures: u8 = 0,
scene_target_failed: bool = false,
- presented_scene: crt.Frame = .{},
+ /// The post chain, run over the frame in scene_tex.
+ post: Post = .{},
pointer_present: bool = false,
arrow_cursor: ?*c.SDL_Cursor = null,
link_cursor: ?*c.SDL_Cursor = null,
+ box_cursor: ?*c.SDL_Cursor = null,
pointer_shape: pardes.Surface.PointerShape = .arrow,
pointer_mapped: bool = false,
pointer_cell: ?MouseCell = null,
+ /// The core the hit test asks (hitTest), while a local session runs;
+ /// null attached, where the session's tag is another process's.
+ hit_core: ?*pardes.Pardes = null,
capture: bool = false,
+ /// Pixels the capture holds past the grid (PARDES_TEST_PAD).
+ capture_pad: u32 = 0,
capture_dir: []const u8 = "",
+ /// PARDES_TEST_SERIES: every captured frame is kept too, numbered, for a
+ /// feel review's frame series (docs/render-pipeline.md §8.4).
+ capture_series: bool = false,
+ captured: u32 = 0,
capture_tex: ?*c.SDL_GPUTexture = null,
capture_tex_w: u32 = 0,
capture_tex_h: u32 = 0,
@@ -1817,7 +1529,6 @@ const Gui = struct {
capture_xfer_size: u32 = 0,
soft_present: bool = false,
- transparent: bool = false,
surface_opacity: bool = false,
applied_window_opacity: u8 = 100,
soft_renderer: ?*c.SDL_Renderer = null,
@@ -1886,17 +1597,27 @@ fn deinitFallbackFonts(g: *Gui, gpa: std.mem.Allocator) void {
}
}
-fn fontForCodepoint(g: *const Gui, cp: u32) *c.UIFont {
- if (c.ui_font_has_glyph(g.font, @intCast(cp)) != 0) return g.font;
- for (g.fallbacks[0..g.fallback_count]) |loaded| {
- const face = loaded.?.face;
- if (c.ui_font_has_glyph(face, @intCast(cp)) != 0) return face;
+const FaceGlyph = struct { face: u8, glyph: u32 };
+
+/// The face and glyph that draw `cp`, the face as a GlyphKey face: 0 is the
+/// primary font and i the fallback i - 1. A codepoint no face has draws the
+/// primary's .notdef.
+fn glyphForCodepoint(g: *const Gui, cp: u32) FaceGlyph {
+ const primary = c.ui_font_glyph(g.font, @intCast(cp));
+ if (primary != 0) return .{ .face = 0, .glyph = primary };
+ for (g.fallbacks[0..g.fallback_count], 1..) |loaded, face| {
+ const glyph = c.ui_font_glyph(loaded.?.face, @intCast(cp));
+ if (glyph != 0) return .{ .face = @intCast(face), .glyph = glyph };
}
- return g.font;
+ return .{ .face = 0, .glyph = 0 };
}
const CellLayout = struct { w: f32, h: f32, x_off: f32, y_off: f32 };
-const MouseCell = struct { col: u16, row: u16, body_hit: ?pardes.Mouse.BodyHit = null, tag_hit: ?pardes.TagHit = null };
+const MouseCell = struct { col: u16, row: u16, body_hit: ?pardes.Mouse.BodyHit = null, tag_hit: ?pardes.TagHit = null, rule_above: bool = false };
+
+/// How near a row's top edge a press is on the rule drawn there between two
+/// panes: the rule's 2 px and a pixel either side, in logical pixels (dp).
+const rule_grab_px: f32 = 3;
const WindowGeometry = struct {
window_w: f32,
window_h: f32,
@@ -1931,7 +1652,9 @@ fn windowCells(g: *const Gui) GridCells {
};
}
-fn windowPointToPixels(geometry: WindowGeometry, x: f32, y: f32) crt.Point {
+const Point = struct { x: f32, y: f32 };
+
+fn windowPointToPixels(geometry: WindowGeometry, x: f32, y: f32) Point {
return .{
.x = x * geometry.pixel_w / geometry.window_w,
.y = y * geometry.pixel_h / geometry.window_h,
@@ -1945,87 +1668,171 @@ test "high-density window coordinates map once to render pixels" {
.pixel_w = 1120,
.pixel_h = 720,
};
- try std.testing.expectEqual(crt.Point{ .x = 700, .y = 240 }, windowPointToPixels(geometry, 350, 120));
+ try std.testing.expectEqual(Point{ .x = 700, .y = 240 }, windowPointToPixels(geometry, 350, 120));
}
fn fixedCellLayout(g: *const Gui) CellLayout {
return .{ .w = @floatFromInt(g.cell_w), .h = @floatFromInt(g.cell_h), .x_off = 0, .y_off = 0 };
}
-fn compactTaglineLayout(g: *const Gui, origin_col: f32) CellLayout {
- const body_w: f32 = @floatFromInt(g.cell_w);
- const tag_w: f32 = @floatFromInt(g.tagline_width);
- return .{
- .w = tag_w,
- .h = @floatFromInt(g.cell_h),
- .x_off = origin_col * (body_w - tag_w),
- .y_off = 0,
- };
-}
-
-fn taglineLayoutForCell(g: *const Gui, col: u16) CellLayout {
- // Canonical tag cells are physical grips; text is drawn by TagLayer.
- return compactTaglineLayout(g, @floatFromInt(col));
-}
+const boxContains = pardes.animation.Box.contains;
-const boxContains = pardes.layout.Box.contains;
-
-const PaintBatch = struct {
- track: ?pardes.layout.Track = null,
+/// What one tier draws, or one track in tiers 2 and 3 (docs/render-pipeline.md
+/// §3.4), in this order: its cells, its images, then its decor.
+const Group = struct {
+ track: ?pardes.animation.Track = null,
cell_start: u32 = 0,
cell_count: u32 = 0,
image_start: u32 = 0,
image_count: u32 = 0,
+ decor_start: u32 = 0,
+ decor_count: u32 = 0,
+ /// The first `under_count` of the group's decor are drawn before its
+ /// cells, under them (a theme's tag plaques, whose cells let them show).
+ under_count: u32 = 0,
};
-const PaintPlan = struct {
- batches: [pardes.MAX_PANES * 2 + 1]PaintBatch = @splat(.{}),
- len: usize = 1,
+/// The frame's draw groups, bottom to top: tier 0 (the page and the panes
+/// standing still), a group for each track in paint order (tier 2 moving and
+/// opening, tier 3 closing), tier 4 (floating: the notices, then the guides
+/// and the debug box, which the core paints over them) and tier 5 (ink: the
+/// bar cursors; the pet and the touch overlay draw after it). Tier 1 is the
+/// focus lift, which does not exist yet.
+const Groups = struct {
+ items: [pardes.MAX_PANES * 2 + 4]Group = @splat(.{}),
+ /// Groups 1 through `tracks` are the tracks'.
+ tracks: usize = 0,
+ notices: usize = 1,
+ guides: usize = 2,
+ ink: usize = 3,
+ len: usize = 4,
};
-fn makePaintPlan(tracks: []const pardes.layout.Track, has_diff: bool) PaintPlan {
- var plan: PaintPlan = .{};
- for ([_]pardes.layout.Phase{ .moving, .opening, .closing }) |phase| {
- for (tracks) |track| {
- if (!track.active() or track.phase != phase) continue;
- if (track.effect.needsPreviousGrid() and !has_diff) continue;
- std.debug.assert(plan.len < plan.batches.len);
- plan.batches[plan.len].track = track;
- plan.len += 1;
- }
+fn makeGroups(tracks: []const pardes.animation.Track, has_diff: bool) Groups {
+ var groups: Groups = .{};
+ for (tracks) |track| {
+ if (!track.active()) continue;
+ if (track.effect.needsPreviousGrid() and !has_diff) continue;
+ std.debug.assert(groups.tracks < pardes.MAX_PANES * 2);
+ groups.tracks += 1;
+ groups.items[groups.tracks].track = track;
}
- return plan;
+ groups.notices = groups.tracks + 1;
+ groups.guides = groups.tracks + 2;
+ groups.ink = groups.tracks + 3;
+ groups.len = groups.tracks + 4;
+ return groups;
}
-fn paintBatchAt(plan: *const PaintPlan, col: u16, row: u16) usize {
- for (plan.batches[1..plan.len], 1..) |batch, index| {
- if (batch.track.?.phase == .closing) continue;
- if (boxContains(batch.track.?.to, col, row)) return index;
+/// The group of the track whose pane covers this cell, else tier 0.
+fn groupAt(groups: *const Groups, col: u16, row: u16) usize {
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ if (group.track.?.phase == .closing) continue;
+ if (boxContains(group.track.?.to, col, row)) return index;
}
return 0;
}
-fn paintBatchForSerial(plan: *const PaintPlan, serial: u32) usize {
- for (plan.batches[1..plan.len], 1..) |batch, index|
- if (batch.track.?.serial == serial) return index;
+fn groupOf(groups: *const Groups, serial: u32) usize {
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index|
+ if (group.track.?.serial == serial) return index;
return 0;
}
-fn panelCellCoord(track: pardes.layout.Track, col: u16, row: u16) u32 {
+/// A notice floats over the panes and its pane's picture (tier 4) while
+/// nothing moves; while anything does it stays in its own pane's group, under
+/// whatever pane slides, opens or closes over it.
+fn noticeGroup(groups: *const Groups, layer: *const pardes.Layer) usize {
+ if (groups.tracks > 0) return groupAt(groups, layer.viewport.x, layer.viewport.y);
+ return groups.notices;
+}
+
+/// What draws a grid cell, marked once a frame from the layers and the
+/// regions (coverFrame), so the cell loops read it rather than search.
+const Cover = packed struct(u16) {
+ /// A layer draws it; the grid's copy is not drawn.
+ layer: bool = false,
+ /// Under a guide or the debug box: drawn from the grid over the panes.
+ floating: bool = false,
+ /// In a pane's grip, `grip_offset` cells from its left: the grip's
+ /// glyph is the cell that far to the left.
+ grip: bool = false,
+ grip_offset: u4 = 0,
+ /// In the focused pane's or column's tag rows.
+ focus: bool = false,
+ /// At a column's left edge, where a tag's anchor is inset.
+ anchor: bool = false,
+ /// In a dirty pane's grip.
+ dirty: bool = false,
+ /// In a pane's grip (not a column's).
+ pane_grip: bool = false,
+ /// In a grip's first row, where its button is.
+ grip_top: bool = false,
+ _: u4 = 0,
+};
+
+/// Marks the grid cells a body or tag layer covers, which the layers paint
+/// themselves, and what the regions say of the rest. Filling each rectangle
+/// once replaces scanning every layer for every cell, which was a third of
+/// the gui's CPU on a full screen of text.
+fn coverFrame(cover: []Cover, cols: u16, rows: u16, body_layers: []const pardes.Layer, tag_layers: []const pardes.Layer, regions: []const pardes.Region) void {
+ @memset(cover, .{});
+ const mark = struct {
+ fn rect(into: []Cover, width: u16, height: u16, r: pardes.Rect, comptime field: []const u8, value: anytype) void {
+ const right = @min(width, @as(u32, r.x) + r.w);
+ if (r.x >= right) return;
+ var y: u32 = r.y;
+ while (y < @min(height, @as(u32, r.y) + r.h)) : (y += 1)
+ for (into[y * width ..][r.x..right]) |*cell| {
+ @field(cell, field) = value;
+ };
+ }
+ };
+ for (body_layers) |*layer| {
+ if (layer.rows != 0) mark.rect(cover, cols, rows, layer.viewport, "layer", true);
+ }
+ for (tag_layers) |*layer| {
+ if (layer.rows != 0) mark.rect(cover, cols, rows, .{ .x = layer.viewport.x, .y = layer.viewport.y, .w = layer.viewport.w, .h = layer.rows }, "layer", true);
+ }
+ // The column bar's rows, which the focused column's tint spans.
+ var bar: ?pardes.Rect = null;
+ for (regions) |region| {
+ if (region.kind == .column_grip) bar = region.rect;
+ }
+ for (regions) |region| switch (region.kind) {
+ .grip, .column_grip => {
+ mark.rect(cover, cols, rows, region.rect, "grip", true);
+ for (0..@min(region.rect.w, 16)) |offset| mark.rect(cover, cols, rows, .{ .x = region.rect.x +| @as(u16, @intCast(offset)), .y = region.rect.y, .w = 1, .h = region.rect.h }, "grip_offset", @as(u4, @intCast(offset)));
+ if (region.kind == .grip and region.active) mark.rect(cover, cols, rows, region.rect, "focus", true);
+ if (region.dirty) mark.rect(cover, cols, rows, region.rect, "dirty", true);
+ if (region.kind == .grip) mark.rect(cover, cols, rows, region.rect, "pane_grip", true);
+ mark.rect(cover, cols, rows, .{ .x = region.rect.x, .y = region.rect.y, .w = region.rect.w, .h = @min(1, region.rect.h) }, "grip_top", true);
+ },
+ .tag => if (region.active) mark.rect(cover, cols, rows, region.rect, "focus", true),
+ .column => {
+ mark.rect(cover, cols, rows, .{ .x = region.rect.x, .y = 0, .w = 1, .h = rows }, "anchor", true);
+ if (region.active) if (bar) |b| mark.rect(cover, cols, rows, .{ .x = region.rect.x, .y = b.y, .w = region.rect.w, .h = b.h }, "focus", true);
+ },
+ .guide, .debug => mark.rect(cover, cols, rows, region.rect, "floating", true),
+ else => {},
+ };
+}
+
+fn panelCellCoord(track: pardes.animation.Track, col: u16, row: u16) u32 {
const source = track.contentBox();
const x0: u16 = @intFromFloat(@max(0.0, @floor(source.x)));
const y0: u16 = @intFromFloat(@max(0.0, @floor(source.y)));
return @as(u32, row -| y0) << 16 | @as(u32, col -| x0);
}
-fn panelGridSize(track: pardes.layout.Track) u32 {
+fn panelGridSize(track: pardes.animation.Track) u32 {
const source = track.contentBox();
const cols: u16 = @intFromFloat(@min(@as(f32, std.math.maxInt(u16)), @max(1.0, @ceil(source.w))));
const rows: u16 = @intFromFloat(@min(@as(f32, std.math.maxInt(u16)), @max(1.0, @ceil(source.h))));
return @as(u32, rows) << 16 | @as(u32, cols);
}
-fn ndcBox(box: pardes.layout.Box, layout: CellLayout, win_w: f32, win_h: f32) [4]f32 {
+fn ndcBox(box: pardes.animation.Box, layout: CellLayout, win_w: f32, win_h: f32) [4]f32 {
const px0 = layout.x_off + box.x * layout.w;
const py0 = layout.y_off + box.y * layout.h;
const px1 = px0 + box.w * layout.w;
@@ -2040,7 +1847,7 @@ fn ndcBox(box: pardes.layout.Box, layout: CellLayout, win_w: f32, win_h: f32) [4
fn setTransitionFields(
instance: anytype,
- track: ?pardes.layout.Track,
+ track: ?pardes.animation.Track,
layout: CellLayout,
win_w: f32,
win_h: f32,
@@ -2071,10 +1878,19 @@ fn setTransitionFields(
instance.present_y0 = presented[1];
instance.present_x1 = presented[2];
instance.present_y1 = presented[3];
- instance.effect = @intFromEnum(active.effect);
+ instance.effect = @backingInt(active.effect);
instance.progress_bits = @bitCast(active.amount());
instance.serial = active.serial;
instance.cell_coord = cell_coord;
+ // A vertical transition shows its pane only inside the box it grows
+ // into, in whole pixels.
+ if (@hasField(@TypeOf(instance.*), "clip_x0") and active.effect == .vertical) {
+ const box = active.contentBox();
+ instance.clip_x0 = std.math.clamp(@floor(box.x * layout.w), 0, win_w);
+ instance.clip_y0 = std.math.clamp(@floor(box.y * layout.h), 0, win_h);
+ instance.clip_x1 = std.math.clamp(@ceil((box.x + box.w) * layout.w), instance.clip_x0, win_w);
+ instance.clip_y1 = std.math.clamp(@ceil((box.y + box.h) * layout.h), instance.clip_y0, win_h);
+ }
}
pub const run = runNative;
@@ -2096,29 +1912,85 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
log.err("PARDES_TEST requires PARDES_TEST_CAPTURE_DIR", .{});
return error.SdlInit;
}
+ if (test_mode) if (env.get("PARDES_TEST_LATENCY")) |path| {
+ var path_buf: [4096]u8 = undefined;
+ if (std.fmt.bufPrintSentinel(&path_buf, "{s}", .{path}, 0)) |z|
+ latency_fd = libc.open(z, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true, .CLOEXEC = true }, @as(libc.mode_t, 0o644))
+ else |_| {}
+ };
+ // SDL frees with whichever functions are current, so they go in before
+ // its first call, while nothing of SDL's exists yet.
+ sdl_allocator = gpa;
+ if (!c.SDL_SetMemoryFunctions(sdl_heap.malloc, sdl_heap.calloc, sdl_heap.realloc, sdl_heap.free)) {
+ log.err("SDL_SetMemoryFunctions: {s}", .{c.SDL_GetError()});
+ return error.SdlInit;
+ }
_ = c.SDL_SetHint("SDL_JOYSTICK_HIDAPI", "1"); // SDL_HINT_JOYSTICK_HIDAPI
_ = c.SDL_SetHint("SDL_JOYSTICK_HIDAPI_STEAMDECK", "1"); // ..._STEAMDECK
if (!c.SDL_Init(c.SDL_INIT_VIDEO | c.SDL_INIT_GAMEPAD)) {
log.err("SDL_Init: {s}", .{c.SDL_GetError()});
return error.SdlInit;
}
- var win_flags: c.SDL_WindowFlags = c.SDL_WINDOW_RESIZABLE;
+ // SDL allocates from gpa (above), so what it still holds at exit is in a
+ // Debug build's leak report. The window, the GPU device and everything
+ // made on it go back first (the defers below run before this one). What
+ // is left is SDL 3.4.4's: its Vulkan backend never frees two 32-byte
+ // arrays per command buffer (VULKAN_INTERNAL_DestroyCommandPool; SDL's
+ // main branch frees them).
+ defer c.SDL_Quit();
+ // No title bar or frame from anyone: borderless asks the compositor for
+ // none (xdg-decoration's client side, which SDL then leaves undrawn).
+ var win_flags: c.SDL_WindowFlags = c.SDL_WINDOW_RESIZABLE | c.SDL_WINDOW_BORDERLESS;
if (!test_mode) win_flags |= c.SDL_WINDOW_HIGH_PIXEL_DENSITY;
+ // A test run renders to the capture texture; keep it off the desktop.
+ if (test_mode) win_flags |= c.SDL_WINDOW_HIDDEN;
const native_wayland = !test_mode and std.mem.eql(u8, std.mem.span(c.SDL_GetCurrentVideoDriver()), "wayland");
// Background-only opacity needs per-pixel alpha; whole-window compositor
// opacity would dim the text as well. SDL requires this flag at creation.
- const surface_opacity = config.gui_transparent or native_wayland;
+ const surface_opacity = native_wayland;
if (surface_opacity) win_flags |= c.SDL_WINDOW_TRANSPARENT;
- const window = c.SDL_CreateWindow("pardes", 1120, 720, win_flags) orelse {
+ // `--geometry=WxH[+X+Y]`, as X11 programs take it.
+ var want_w: c_int = 1120;
+ var want_h: c_int = 720;
+ var want_at: ?[2]c_int = null;
+ if (opts_in.geometry) |spec| geometry: {
+ const x_at = std.mem.indexOfScalar(u8, spec, 'x') orelse break :geometry;
+ const plus = std.mem.indexOfAnyPos(u8, spec, x_at, "+-") orelse spec.len;
+ want_w = std.math.clamp(std.fmt.parseInt(c_int, spec[0..x_at], 10) catch break :geometry, 200, 16384);
+ want_h = std.math.clamp(std.fmt.parseInt(c_int, spec[x_at + 1 .. plus], 10) catch break :geometry, 120, 16384);
+ if (plus == spec.len) break :geometry;
+ const second = std.mem.indexOfAnyPos(u8, spec, plus + 1, "+-") orelse break :geometry;
+ const gx = std.fmt.parseInt(c_int, spec[plus + @intFromBool(spec[plus] == '+') .. second], 10) catch break :geometry;
+ const gy = std.fmt.parseInt(c_int, spec[second + @intFromBool(spec[second] == '+') ..], 10) catch break :geometry;
+ want_at = .{ gx, gy };
+ }
+ const window = c.SDL_CreateWindow("pardes", want_w, want_h, win_flags) orelse {
log.err("SDL_CreateWindow: {s}", .{c.SDL_GetError()});
return error.SdlInit;
};
+ defer c.SDL_DestroyWindow(window);
+ if (want_at) |at| _ = c.SDL_SetWindowPosition(window, at[0], at[1]);
+ updateDisplayScale(window);
if (native_wayland) log.info("Wayland opacity: background-only transparent surface", .{});
- const arrow_cursor = c.SDL_CreateCursor(&p9_arrow_set, &p9_arrow_mask, 16, 16, 1, 1);
+ // On Linux the desktop's own cursor theme draws them (the compositor's
+ // cursor-shape protocol, else XCURSOR_THEME), at its size and scale:
+ // the arrow is its default, acme's box its move, as the plan9 theme
+ // has them. Elsewhere acme's bitmaps, at 16 pixels.
+ const themed_cursors = builtin.os.tag == .linux;
+ const arrow_cursor = if (themed_cursors)
+ c.SDL_CreateSystemCursor(c.SDL_SYSTEM_CURSOR_DEFAULT)
+ else
+ c.SDL_CreateCursor(&p9_arrow_set, &p9_arrow_mask, 16, 16, 1, 1);
defer if (arrow_cursor) |cursor| c.SDL_DestroyCursor(cursor);
const link_cursor = c.SDL_CreateSystemCursor(c.SDL_SYSTEM_CURSOR_POINTER);
defer if (link_cursor) |cursor| c.SDL_DestroyCursor(cursor);
+ // Its hot spot the middle, as acme's {-7, -7} offset puts it.
+ const box_cursor = if (themed_cursors)
+ c.SDL_CreateSystemCursor(c.SDL_SYSTEM_CURSOR_MOVE)
+ else
+ c.SDL_CreateCursor(&p9_box_set, &p9_box_mask, 16, 16, 7, 7);
+ defer if (box_cursor) |cursor| c.SDL_DestroyCursor(cursor);
if (arrow_cursor) |cur| {
_ = c.SDL_SetCursor(cur);
} else log.err("SDL_CreateCursor: {s}", .{c.SDL_GetError()});
@@ -2126,6 +1998,7 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
log.err("SDL_CreateGPUDevice: {s}", .{c.SDL_GetError()});
return error.SdlInit;
};
+ defer c.SDL_DestroyGPUDevice(device);
var soft_present = false;
var soft_renderer: ?*c.SDL_Renderer = null;
const force_soft = if (env.get("PARDES_SOFT_PRESENT")) |raw|
@@ -2172,23 +2045,36 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
else
c.SDL_GetGPUSwapchainTextureFormat(device, window);
+ font_allocator = gpa;
const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)) orelse {
log.err("ui_font_new failed", .{});
return error.FontInit;
};
- const px: f32 = 27.0;
- const scale = c.ui_font_scale_for_height(font, px);
+ // HarfBuzz's process-wide objects are made once and never freed: made
+ // from the default heap, they stay out of a Debug build's leak report.
+ font_allocator = std.heap.smp_allocator;
+ c.ui_font_prime(font);
+ font_allocator = gpa;
+ // A harness forcing a density (PARDES_TEST_SCALE) draws the text as a
+ // person on that display would size it, so its chrome is seen at the
+ // proportion it has there; PARDES_TEST_FONT_SCALE sizes the text alone
+ // (a density's text with 1x chrome: how it looked before dp). A live
+ // window keeps the size the user sets.
+ const font_scale: f32 = if (env.get("PARDES_TEST_FONT_SCALE")) |v| std.fmt.parseFloat(f32, v) catch display_scale else display_scale;
+ const px: f32 = if (test_mode) 27.0 * std.math.clamp(font_scale, 1, 4) else 27.0;
var cw: c_int = 10;
var chh: c_int = 20;
var asc: c_int = 16;
- c.ui_font_cell_metrics(font, scale, &cw, &chh, &asc);
+ c.ui_font_cell_metrics(font, px, &cw, &chh, &asc);
const cell_w: u32 = @intCast(@max(cw, 1));
const cell_h: u32 = @intCast(@max(chh, 1));
const tagline = taglineRaster(font, px, cell_w, cell_h, config.gui_tagline_font_percent);
if (test_mode) {
const cols = envU16(env, "PARDES_TEST_COLS") orelse 80;
const rows = envU16(env, "PARDES_TEST_ROWS") orelse 24;
- _ = c.SDL_SetWindowSize(window, @intCast(cols * cell_w), @intCast(rows * cell_h));
+ // PARDES_TEST_PAD: extra pixels past the grid, as a real window has.
+ const pad = envU16(env, "PARDES_TEST_PAD") orelse 0;
+ _ = c.SDL_SetWindowSize(window, @intCast(cols * cell_w + pad), @intCast(rows * cell_h + pad));
_ = c.SDL_SyncWindow(window);
}
@@ -2219,10 +2105,11 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
var ax_info = c.SDL_GPUTransferBufferCreateInfo{ .usage = c.SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD, .size = atlas_w * atlas_h, .props = 0 };
const atlas_xfer = c.SDL_CreateGPUTransferBuffer(device, &ax_info) orelse return error.GpuCreate;
- const pipeline = try makePipeline(device, swapchain_format);
+ const pipeline = try makePipeline(device, swapchain_format, frag_spv, 1, std.mem.zeroes(c.SDL_GPUColorTargetBlendState));
+ const pipeline_over = try makePipeline(device, swapchain_format, frag_spv, 1, premultipliedBlend());
+ const decor_pipeline = try makePipeline(device, swapchain_format, decor_frag_spv, 0, backgroundLayerBlend());
const overlay_pipeline = try makeOverlayPipeline(device, swapchain_format);
const image_pipeline = try makeImagePipeline(device, swapchain_format);
- const crt_pipeline = try makeCrtPipeline(device, swapchain_format);
const overlay_buffer_size: u32 = @intCast(max_overlay_vertices * @sizeOf(OverlayVertex));
var ovb_info = c.SDL_GPUBufferCreateInfo{ .usage = c.SDL_GPU_BUFFERUSAGE_VERTEX, .size = overlay_buffer_size, .props = 0 };
@@ -2246,12 +2133,14 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
.window = window,
.arrow_cursor = arrow_cursor,
.link_cursor = link_cursor,
+ .box_cursor = box_cursor,
.device = device,
.swapchain_format = swapchain_format,
.pipeline = pipeline,
+ .pipeline_over = pipeline_over,
+ .decor_pipeline = decor_pipeline,
.overlay_pipeline = overlay_pipeline,
.image_pipeline = image_pipeline,
- .crt_pipeline = crt_pipeline,
.atlas_tex = atlas_tex,
.atlas_sampler = atlas_sampler,
.linear_sampler = linear_sampler,
@@ -2264,8 +2153,7 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
.image_capacity = initial_image_capacity,
.font = font,
.px = px,
- .scale = scale,
- .tagline_scale = tagline.scale,
+ .tagline_px = tagline.px,
.tagline_percent = config.gui_tagline_font_percent,
.tagline_width = tagline.width,
.tagline_height = tagline.height,
@@ -2276,21 +2164,49 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
.atlas_stage = atlas_stage,
.glyphs = std.AutoHashMap(GlyphKey, Slot).init(gpa),
.capture = test_mode,
+ .capture_pad = if (test_mode) envU16(env, "PARDES_TEST_PAD") orelse 0 else 0,
+ .capture_series = test_mode and env.get("PARDES_TEST_SERIES") != null,
.capture_dir = capture_dir orelse "",
.soft_present = soft_present,
- .transparent = config.gui_transparent,
+ .demo = if (env.get("PARDES_FRAMES_DEMO")) |name| pardes.FrameStats.named(name) orelse &.{} else &.{},
+ .demo_name = env.get("PARDES_FRAMES_DEMO") orelse "",
+ .demo_next = if (env.get("PARDES_FRAMES_DEMO")) |name| (if (pardes.FrameStats.named(name) != null) @as(?usize, 0) else null) else null,
.surface_opacity = surface_opacity,
.soft_renderer = soft_renderer,
};
+ // The pipelines, textures and buffers the Gui holds, whatever they were
+ // regrown to; the image ones are released below.
+ defer {
+ c.SDL_ReleaseGPUGraphicsPipeline(device, g.pipeline);
+ c.SDL_ReleaseGPUGraphicsPipeline(device, g.pipeline_over);
+ c.SDL_ReleaseGPUGraphicsPipeline(device, g.decor_pipeline);
+ c.SDL_ReleaseGPUGraphicsPipeline(device, g.overlay_pipeline);
+ c.SDL_ReleaseGPUTexture(device, g.atlas_tex);
+ c.SDL_ReleaseGPUSampler(device, g.atlas_sampler);
+ c.SDL_ReleaseGPUSampler(device, g.linear_sampler);
+ c.SDL_ReleaseGPUTransferBuffer(device, g.atlas_xfer);
+ c.SDL_ReleaseGPUBuffer(device, g.overlay_vbuf);
+ c.SDL_ReleaseGPUTransferBuffer(device, g.overlay_vxfer);
+ if (g.vbuf) |buffer| c.SDL_ReleaseGPUBuffer(device, buffer);
+ if (g.vxfer) |transfer| c.SDL_ReleaseGPUTransferBuffer(device, transfer);
+ if (g.scene_tex) |texture| c.SDL_ReleaseGPUTexture(device, texture);
+ if (g.capture_tex) |texture| c.SDL_ReleaseGPUTexture(device, texture);
+ if (g.capture_xfer) |transfer| c.SDL_ReleaseGPUTransferBuffer(device, transfer);
+ if (g.gamepad) |pad| c.SDL_CloseGamepad(pad);
+ }
setGuiFontName(&g, "Adwaita Mono");
loadFallbackFonts(&g, gpa);
defer deinitFallbackFonts(&g, gpa);
defer g.glyphs.deinit();
+ defer g.words.deinit(gpa);
defer {
clearNativeImages(&g);
g.native_images.deinit(gpa);
g.presented_images.deinit(gpa);
g.prepared_images.deinit(gpa);
+ g.cover.deinit(gpa);
+ g.decor.deinit(gpa);
+ g.post.deinit(gpa, device);
}
defer c.SDL_ReleaseGPUTransferBuffer(device, g.image_vxfer);
defer c.SDL_ReleaseGPUBuffer(device, g.image_vbuf);
@@ -2298,9 +2214,13 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, attach: ?[]const u
defer if (g.font_bytes.len != 0) gpa.free(g.font_bytes); // set by Font, if it ran
defer c.ui_font_free(g.font);
defer gpa.free(g.scroll_edge); // grown on demand by stepScroll
- _ = c.ui_font_raster(font, scale, ' ', atlas_stage.ptr, @intCast(atlas_w), @intCast(cell_w), @intCast(cell_h), asc);
- g.pen_x = cell_w;
+ defer g.glide.deinit(gpa);
+ resetGlyphAtlas(&g);
+ // The window is dragged by the workspace tag's blank (hitTest): the
+ // compositor moves it, as it does a title bar.
+ if (!test_mode and !c.SDL_SetWindowHitTest(window, hitTest, &g))
+ log.warn("SDL_SetWindowHitTest: {s}", .{c.SDL_GetError()});
if (attach) |requested| return attachRequested(gpa, &g, requested);
var attached: ?detached_client.Client = null;
try localSession(init, &g, opts_in, test_mode, &attached);
@@ -2320,9 +2240,12 @@ fn localSession(
defer pardes.memory.deinit();
pardes.image.start(io, allocs.image); // stb_image allocator for image panes
if (comptime pardes.pdf_enabled) pardes.pdf.start(allocs.pdf);
+ // Pages render on lanes off the loop (pdf_view.workers).
+ if (comptime pardes.pdf_enabled) pardes.panes.Pdf.workers = io;
pardes.syntax.start(allocs.tree_sitter);
defer {
pardes.image.stop();
+ if (comptime pardes.pdf_enabled) pardes.panes.Pdf.dropKept();
if (comptime pardes.pdf_enabled) pardes.pdf.stop();
pardes.syntax.stop();
}
@@ -2341,27 +2264,33 @@ fn localSession(
var core = if (opts.load_path) |lp| blk: {
const bytes = try @import("../fs.zig").readFile(gpa, lp);
defer gpa.free(bytes);
- break :blk try pardes.Pardes.initFromDump(allocs.pardes, opts, bytes);
+ break :blk try pardes.dump.initFromDump(allocs.pardes, opts, bytes);
} else try pardes.Pardes.init(allocs.pardes, opts);
defer core.deinit();
+ g.hit_core = core;
+ defer g.hit_core = null;
+ core.windowed = true;
core.native_images = true;
+ core.native_image_patches = true;
observeGuiFont(g, core);
syncTaglineFont(g, core);
+ syncLigatures(g, core);
var prompt_rcs = host_io.Shell.prepare();
defer prompt_rcs.deinit();
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(0);
- var lsp_workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = io,
.gpa = gpa,
.lsp_allocator = allocs.lsp,
- .lsp_workers = &lsp_workers,
- .sdl_wake = true,
+ .wake_fn = sdlWake,
};
defer {
- lsp_workers.wait();
+ if (queue.lsp_task) |*task| task.future.cancel(io);
+ // Its worker may be waiting on the queue for room.
+ core.stream.cancelTask();
queue.deinit();
}
var pipe_tasks: PipeTasks = .{};
@@ -2400,14 +2329,22 @@ fn localSession(
.watches = &watches,
.fs = fs,
.test_mode = test_mode,
+ .test_clock = if (test_mode) host_io.testClock() else null,
+ .test_hz = if (std.c.getenv("PARDES_TEST_HZ")) |hz| @max(1, std.fmt.parseInt(u64, std.mem.span(hz), 10) catch 60) else 60,
};
defer shell.shutdownPtys();
+ defer shell.shaders.deinit(gpa, inotify_fd, &watches);
+ // A virtual clock never blinks: goldens and feel series hold still.
+ g.no_blink = shell.test_clock != null;
+ frame_probe = &core.frames;
+ frame_capture_dir = if (std.c.getenv("PARDES_FRAMES_CAPTURE")) |dir| std.mem.span(dir) else null;
const host = shell.host();
core.host = host;
while (core.nextEffect()) |e| core.perform(e);
- for (&ptys, 0..) |*slot, id| if (slot.*) |*pt|
- try spawnReader(gpa, pt, @intCast(id), gens[id], &queue);
+ for (&ptys, 0..) |*slot, id| if (slot.*) |*pt| {
+ pt.reader = try queue.startReader(.{ .handle = pt.fd, .flags = .{ .nonblocking = false } }, @intCast(id), gens[id]);
+ };
if (inotify_fd >= 0) {
watch_stop = try stopPipe();
watch_reader = try std.Thread.spawn(.{}, watchThread, .{ inotify_fd, watch_stop[0], &queue });
@@ -2418,10 +2355,13 @@ fn localSession(
if (test_mode) setStdinRaw() catch {};
shell.threads_ok = true;
- pardes.lsp.setStatusSink(&queue, lspStatusSink);
+ pardes.lsp.setStatusSink(&queue, Queue.lspStatus);
defer pardes.lsp.setStatusSink(null, null);
+ host_io.setExitWake(&queue, Queue.wakeForExit);
+ defer host_io.setExitWake(null, null);
while (!core.quit) {
+ pardes.turn.bump(&pardes.turn.restores);
try core.pump(host);
if (core.quit) break; // a session that ended does not restore into one
if (core.takeAttach()) |req| {
@@ -2439,12 +2379,12 @@ fn localSession(
}
}
if (core.takeRestore()) |rp| blk: {
- const bytes = filesystem.readRestore(gpa, rp) catch |err| {
+ const bytes = filesystem.readRestore(gpa, rp, core.settings.dump_dir.get()) catch |err| {
core.reportError(core.active, "Restore", err);
break :blk;
};
defer gpa.free(bytes);
- const nc = core.restore(bytes) catch |err| {
+ const nc = dump.restore(core, bytes, rp) catch |err| {
core.reportError(core.active, "Restore", err);
break :blk;
};
@@ -2464,14 +2404,18 @@ fn localSession(
g.presented_images.clearRetainingCapacity();
g.prepared_images.clearRetainingCapacity();
nc.native_images = true;
+ nc.native_image_patches = true;
nc.host = host;
- if (fs) |f| f.reset(core);
+ if (fs) |f| f.reset(nc);
+ nc.windowed = true;
core.deinit();
core = nc;
+ g.hit_core = nc;
shell.core = nc;
shell.surface = null;
observeGuiFont(g, core);
syncTaglineFont(g, core);
+ syncLigatures(g, core);
}
}
@@ -2564,6 +2508,7 @@ fn attachedLoop(gpa: std.mem.Allocator, g: *Gui, client: *detached_client.Client
in.post(.{ .paste = text });
},
.open_link => |url| look.openLink(url),
+ .post => dirty = true,
}
}
try link;
@@ -2579,32 +2524,27 @@ fn attachedLoop(gpa: std.mem.Allocator, g: *Gui, client: *detached_client.Client
geom = now;
try attachedResize(client, g, now.cols, now.rows);
}
- if (!dirty) continue;
+ // The session's chain, its files compiled there.
+ g.post.sync(gpa, g.device, g.swapchain_format, client.post.list(), client.post_key, null);
+ if (!dirty) {
+ // As a local window does: a chain that moves on its own redraws
+ // alone, once a refresh.
+ if (g.post.animating(client.post.animation) and g.scene_tex != null and
+ c.SDL_GetTicksNS() -| g.post.last_ns + std.time.ns_per_ms >= refreshNs(g)) redrawPost(g, gpa);
+ continue;
+ }
dirty = false;
paintAttached(g, gpa, client);
}
}
fn paintAttached(g: *Gui, gpa: std.mem.Allocator, client: *detached_client.Client) void {
- var surface: pardes.Surface = .{
- .cols = client.cols,
- .rows = client.rows,
- .cells = client.grid.items,
- .cursor = if (client.cursor) |cu| .{ .x = cu.x, .y = cu.y, .bar = cu.bar } else null,
- .pointer_shape = client.pointer_shape,
- .body_layers = client.body_layers,
- .tag_layers = client.tag_layers,
- };
- const chrome = frameChromeBg(&surface);
+ var surface = attachedSurface(client);
_ = renderFrame(
g,
gpa,
null,
&surface,
- null,
- chrome,
- chrome,
- .{},
false,
) catch |err| blk: {
log.err("render: {t}", .{err});
@@ -2612,17 +2552,70 @@ fn paintAttached(g: *Gui, gpa: std.mem.Allocator, client: *detached_client.Clien
};
}
-fn frameChromeBg(surface: *const pardes.Surface) [3]u8 {
- if (surface.rows == 0 or surface.cols == 0) return bg_default;
- for (surface.cells[0..surface.cols]) |cell| {
- if (cell.default or cell.style.font_role != .tagline) continue;
- return switch (cell.style.bg) {
- .default => bg_default,
- .index => |i| palColor(i),
- .rgb => |rgb| rgb,
- };
- }
- return bg_default;
+/// The session's frame as a surface: its cells, layers, regions and palette,
+/// so its chrome is drawn from them as a local one's is.
+fn attachedSurface(client: *const detached_client.Client) pardes.Surface {
+ var surface: pardes.Surface = .{
+ .cols = client.cols,
+ .rows = client.rows,
+ .cells = client.grid.items,
+ .cursor = if (client.cursor) |cu| .{ .x = cu.x, .y = cu.y, .bar = cu.bar } else null,
+ .pointer_shape = client.pointer_shape,
+ .body_layers = client.body_layers,
+ .tag_layers = client.tag_layers,
+ .chrome = client.chrome,
+ };
+ const placed = client.regions.items[0..@min(client.regions.items.len, surface.regions.len)];
+ @memcpy(surface.regions[0..placed.len], placed);
+ surface.nregions = @intCast(placed.len);
+ return surface;
+}
+
+test "an attached frontend draws the session's chrome from its frame alone" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ // A gui-shaped core, whose tags and notices are layers.
+ core.update(.{ .resize = .{ .cols = 80, .rows = 24, .row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 6, .tagline_h = 12 } } });
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ core.settings.focus_tint = true;
+ try std.testing.expect(core.executeBuiltinLine(0, "Msg a notice with a rule under it"));
+ core.sync();
+ // Past its slide into place, where its rule shows.
+ for (0..30) |_| core.update(.tick);
+ const s = try core.render(core.scratch.allocator());
+
+ const wire = @import("../detached/wire.zig");
+ var client: detached_client.Client = .{ .gpa = gpa };
+ defer client.deinit();
+ var welcome: [64]u8 = undefined;
+ try client.in.appendSlice(gpa, try wire.encodeServer(&welcome, .{ .welcome = .{ .slot = 0, .cols = s.cols, .rows = s.rows } }));
+ const out = try gpa.alloc(u8, wire.frameBound(s.cols, s.rows) + wire.layersBound(&s.body_layers, &s.tag_layers, s.regionList()));
+ defer gpa.free(out);
+ try client.in.appendSlice(gpa, try wire.encodeFrameLayers(out, s.cols, s.rows, null, s.pointer_shape, s.cells, &.{}, &s.body_layers, &s.tag_layers, s.regionList(), s.chrome));
+ _ = try client.next();
+ _ = try client.next();
+ const attached = attachedSurface(&client);
+
+ var g: Gui = undefined;
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+ const local = try gpa.dupe(CellInstance, g.decor.items);
+ defer gpa.free(local);
+ try std.testing.expect(local.len > 8);
+ try std.testing.expect(groups.items[groups.notices].decor_count != 0);
+ try buildDecor(&g, gpa, &attached, &groups, fixedCellLayout(&g), 800, 480, true);
+ try std.testing.expectEqualSlices(u8, std.mem.sliceAsBytes(local), std.mem.sliceAsBytes(g.decor.items));
}
fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
@@ -2634,9 +2627,12 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
defer pardes.memory.deinit();
pardes.image.start(io, allocs.image);
if (comptime pardes.pdf_enabled) pardes.pdf.start(allocs.pdf);
+ // Pages render on lanes off the loop (pdf_view.workers).
+ if (comptime pardes.pdf_enabled) pardes.panes.Pdf.workers = io;
pardes.syntax.start(allocs.tree_sitter);
defer {
pardes.image.stop();
+ if (comptime pardes.pdf_enabled) pardes.panes.Pdf.dropKept();
if (comptime pardes.pdf_enabled) pardes.pdf.stop();
pardes.syntax.stop();
}
@@ -2655,7 +2651,7 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
const core = if (opts.load_path) |lp| blk: {
const bytes = try @import("../fs.zig").readFile(gpa, lp);
defer gpa.free(bytes);
- break :blk try pardes.Pardes.initFromDump(allocs.pardes, opts, bytes);
+ break :blk try pardes.dump.initFromDump(allocs.pardes, opts, bytes);
} else try pardes.Pardes.init(allocs.pardes, opts);
defer core.deinit();
if (opts.load_path == null)
@@ -2666,15 +2662,15 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(0);
- var lsp_workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = io,
.gpa = gpa,
.lsp_allocator = allocs.lsp,
- .lsp_workers = &lsp_workers,
- .sdl_wake = false,
};
defer {
- lsp_workers.wait();
+ if (queue.lsp_task) |*task| task.future.cancel(io);
+ // Its worker may be waiting on the queue for room.
+ core.stream.cancelTask();
queue.deinit();
}
var pipe_tasks: PipeTasks = .{};
@@ -2700,11 +2696,14 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
const host = shell.host();
core.host = host;
while (core.nextEffect()) |e| core.perform(e);
- for (&ptys, 0..) |*slot, id| if (slot.*) |*pt|
- try spawnReader(gpa, pt, @intCast(id), gens[id], &queue);
+ for (&ptys, 0..) |*slot, id| if (slot.*) |*pt| {
+ pt.reader = try queue.startReader(.{ .handle = pt.fd, .flags = .{ .nonblocking = false } }, @intCast(id), gens[id]);
+ };
shell.threads_ok = true;
- pardes.lsp.setStatusSink(&queue, lspStatusSink);
+ pardes.lsp.setStatusSink(&queue, Queue.lspStatus);
defer pardes.lsp.setStatusSink(null, null);
+ host_io.setExitWake(&queue, Queue.wakeForExit);
+ defer host_io.setExitWake(null, null);
setStdinRaw() catch {}; // stdin may be a pipe, not a pty — best effort
@@ -2736,6 +2735,9 @@ fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
const StdinFeed = struct {
parser: vaxis.Parser = .{},
+ /// Inside the driver's bracketed paste: its keys are the paste's text.
+ in_paste: bool = false,
+ paste: std.ArrayList(u8) = .empty,
cache: vaxis.GraphemeCache = .{},
buf: [1024]u8 = undefined,
fill: usize = 0,
@@ -2758,13 +2760,17 @@ const StdinFeed = struct {
}
var fds = [_]posix.pollfd{.{ .fd = 0, .events = posix.POLL.IN, .revents = 0 }};
- _ = posix.poll(&fds, 16) catch return out;
+ pardes.turn.rest();
+ const polled = posix.poll(&fds, 16);
+ pardes.turn.wake();
+ _ = polled catch return out;
if ((fds[0].revents & posix.POLL.IN) == 0) {
if ((fds[0].revents & (posix.POLL.HUP | posix.POLL.ERR)) != 0) out.eof = true;
return out;
}
const rn = libc.read(0, f.buf[f.fill..].ptr, f.buf.len - f.fill);
if (rn < 0) return out;
+ if (rn > 0) latencyNote("R {d}\n", .{monoNs()});
if (rn == 0) {
out.eof = true;
return out;
@@ -2774,6 +2780,67 @@ const StdinFeed = struct {
var seq_start: usize = 0;
while (seq_start < len) {
+ // ESC]777;mouse;<down|up|motion>;<SDL button, 0 for none>;<x>;<y>[;<mods>]BEL
+ // ESC]777;mouse;wheel;<amount>;<x>;<y>[;<mods>]BEL
+ // A mouse event at window pixels, built as SDL would and run
+ // through dispatch, so a driver exercises the real pointer path
+ // (pixel to cell, tag and body hits). SGR mouse carries only cells.
+ const mouse_prefix = "\x1b]777;mouse;";
+ if (std.mem.startsWith(u8, f.buf[seq_start..len], mouse_prefix)) {
+ const body = f.buf[seq_start + mouse_prefix.len .. len];
+ const end = std.mem.indexOfScalar(u8, body, 0x07) orelse {
+ std.mem.copyForwards(u8, f.buf[0 .. len - seq_start], f.buf[seq_start..len]);
+ f.fill = len - seq_start;
+ break;
+ };
+ if (g) |gp| {
+ var parts = std.mem.splitScalar(u8, body[0..end], ';');
+ const kind = parts.next() orelse "";
+ const second = parts.next() orelse "";
+ const button = std.fmt.parseInt(u8, second, 10) catch 0;
+ const x = std.fmt.parseFloat(f32, parts.next() orelse "") catch 0;
+ const y = std.fmt.parseFloat(f32, parts.next() orelse "") catch 0;
+ // An optional fifth field holds modifiers as xterm
+ // counts them: shift 4, meta (alt) 8, ctrl 16.
+ const held = std.fmt.parseInt(u8, parts.next() orelse "0", 10) catch 0;
+ var sev = std.mem.zeroes(c.SDL_Event);
+ if (std.mem.eql(u8, kind, "wheel")) {
+ // ESC]777;mouse;wheel;<y, SDL's sign: up positive>;<x>;<y>BEL:
+ // a whole number is a mouse's notches, else a touchpad's.
+ const amount = std.fmt.parseFloat(f32, second) catch 0;
+ sev.type = c.SDL_EVENT_MOUSE_WHEEL;
+ sev.wheel.y = amount;
+ sev.wheel.integer_y = @intFromFloat(@trunc(amount));
+ sev.wheel.mouse_x = x;
+ sev.wheel.mouse_y = y;
+ } else if (std.mem.eql(u8, kind, "focus")) {
+ // ESC]777;mouse;focus;<1 gained, 0 lost>;0;0BEL
+ sev.type = if (button != 0) c.SDL_EVENT_WINDOW_FOCUS_GAINED else c.SDL_EVENT_WINDOW_FOCUS_LOST;
+ } else if (std.mem.eql(u8, kind, "motion")) {
+ sev.type = c.SDL_EVENT_MOUSE_MOTION;
+ sev.motion.x = x;
+ sev.motion.y = y;
+ sev.motion.state = if (button == 0 or button > 5) 0 else @as(u32, 1) << @intCast(button - 1);
+ } else {
+ sev.type = if (std.mem.eql(u8, kind, "down")) c.SDL_EVENT_MOUSE_BUTTON_DOWN else c.SDL_EVENT_MOUSE_BUTTON_UP;
+ sev.button.button = button;
+ sev.button.down = std.mem.eql(u8, kind, "down");
+ sev.button.x = x;
+ sev.button.y = y;
+ }
+ const before = c.SDL_GetModState();
+ var mods: c.SDL_Keymod = 0;
+ if (held & 4 != 0) mods |= c.SDL_KMOD_LSHIFT;
+ if (held & 8 != 0) mods |= c.SDL_KMOD_LALT;
+ if (held & 16 != 0) mods |= c.SDL_KMOD_LCTRL;
+ c.SDL_SetModState(mods);
+ dispatch(gp, in, &sev);
+ c.SDL_SetModState(before);
+ out.n_events += 1;
+ }
+ seq_start += mouse_prefix.len + end + 1;
+ continue;
+ }
const prefix = "\x1b]777;finger;";
if (std.mem.startsWith(u8, f.buf[seq_start..len], prefix)) {
const body = f.buf[seq_start + prefix.len .. len];
@@ -2782,23 +2849,14 @@ const StdinFeed = struct {
f.fill = len - seq_start;
break;
};
- if (parseFinger(body[0..end])) |finger_in| {
- var finger = finger_in;
+ if (parseFinger(body[0..end])) |finger| {
if (g) |gp| {
var wpw: c_int = 0;
var wph: c_int = 0;
_ = c.SDL_GetWindowSizeInPixels(gp.window, &wpw, &wph);
const win_w: f32 = @floatFromInt(@max(wpw, 1));
const win_h: f32 = @floatFromInt(@max(wph, 1));
- if (mapScenePoint(gp, finger.x * win_w, finger.y * win_h, win_w, win_h)) |m| {
- finger.x = m.x / win_w;
- finger.y = m.y / win_h;
- handleFinger(&gp.touch, in, finger, win_w, win_h, @floatFromInt(gp.cell_w), @floatFromInt(gp.cell_h), @floatFromInt(gp.tagline_width));
- } else {
- finger.kind = .cancel;
- handleFinger(&gp.touch, in, finger, win_w, win_h, @floatFromInt(gp.cell_w), @floatFromInt(gp.cell_h), @floatFromInt(gp.tagline_width));
- in.post(.pointer_leave);
- }
+ handleFinger(&gp.touch, in, finger, win_w, win_h, @floatFromInt(gp.cell_w), @floatFromInt(gp.cell_h), @floatFromInt(gp.tagline_width));
} else if (in.core) |core| {
handleFinger(&grid_touch, in, finger, @floatFromInt(core.screen_w), @floatFromInt(core.screen_h), 1, 1, 1);
}
@@ -2807,7 +2865,9 @@ const StdinFeed = struct {
seq_start += prefix.len + end + 1;
continue;
}
- if (len - seq_start < prefix.len and std.mem.startsWith(u8, prefix, f.buf[seq_start..len])) {
+ if ((len - seq_start < prefix.len and std.mem.startsWith(u8, prefix, f.buf[seq_start..len])) or
+ (len - seq_start < mouse_prefix.len and std.mem.startsWith(u8, mouse_prefix, f.buf[seq_start..len])))
+ {
std.mem.copyForwards(u8, f.buf[0 .. len - seq_start], f.buf[seq_start..len]);
f.fill = len - seq_start;
break;
@@ -2822,16 +2882,22 @@ const StdinFeed = struct {
seq_start += result.n;
const event = result.event orelse continue;
switch (event) {
- .key_press => |key| {
- var text: []const u8 = "";
- if (key.text) |t| text = f.cache.put(t);
- in.post(.{ .key = .{
- .cp = mapKey(effCp(key)),
- .text = text,
- .ctrl = key.mods.ctrl,
- .alt = key.mods.alt,
- .shift = key.mods.shift,
- } });
+ .key_press => |key| if (f.in_paste) {
+ // A newline reads as Ctrl-J, as the tty's paste has it.
+ const text = key.text orelse if (key.codepoint == vaxis.Key.enter or (key.mods.ctrl and key.codepoint == 'j')) "\n" else if (key.codepoint == vaxis.Key.tab) "\t" else "";
+ f.paste.appendSlice(gpa, text) catch {};
+ } else {
+ postKey(in, key, if (key.text) |t| f.cache.put(t) else "");
+ out.n_events += 1;
+ },
+ .paste_start => {
+ f.in_paste = true;
+ f.paste.clearRetainingCapacity();
+ },
+ .paste_end => {
+ f.in_paste = false;
+ if (f.paste.items.len > 0) in.post(.{ .paste = f.paste.items });
+ f.paste.clearAndFree(gpa);
out.n_events += 1;
},
.mouse => |m| {
@@ -2858,6 +2924,8 @@ const StdinFeed = struct {
.col = @intCast(@max(m.col, 0)),
.row = @intCast(@max(m.row, 0)),
.ctrl = m.mods.ctrl,
+ .shift = m.mods.shift,
+ .alt = m.mods.alt,
} });
out.n_events += 1;
}
@@ -2929,8 +2997,8 @@ fn setStdinRaw() !void {
term.lflag.ICANON = false;
term.lflag.IEXTEN = false;
term.lflag.ISIG = false;
- term.cc[@intFromEnum(posix.V.MIN)] = 1;
- term.cc[@intFromEnum(posix.V.TIME)] = 0;
+ term.cc[@backingInt(posix.V.MIN)] = 1;
+ term.cc[@backingInt(posix.V.TIME)] = 0;
try posix.tcsetattr(0, .NOW, term);
}
@@ -2980,6 +3048,81 @@ fn dumpGrid(gpa: std.mem.Allocator, surface: *pardes.Surface) !void {
_ = host_io.writeFd(1, frame);
}
+/// A key parsed from the stdin a test window reads, posted as the tty
+/// posts one (vaxis_input): F-keys, Insert and the keypad included. `text`
+/// is the key's text as the feed keeps it.
+fn postKey(in: *Input, key: vaxis.Key, text: []const u8) void {
+ var ev = vaxis_input.keyEvent(key);
+ ev.key.text = text;
+ in.post(ev);
+}
+
+test "the GUI's stdin keys reach a terminal pane as the tty's do: F5, Insert and the keypad's Up" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
+ defer core.deinit();
+ core.panes[0].?.body.mode = .tty;
+ while (core.nextEffect()) |_| {}
+ var in: Input = .{ .core = core };
+ var parser: vaxis.Parser = .{};
+ var bytes: []const u8 = "\x1b[15~\x1b[2~\x1b[57419u";
+ while (bytes.len > 0) {
+ const result = try parser.parse(bytes, gpa);
+ bytes = bytes[result.n..];
+ if (result.event) |event| switch (event) {
+ .key_press => |key| postKey(&in, key, key.text orelse ""),
+ else => {},
+ };
+ }
+ var written: std.Io.Writer.Allocating = .init(gpa);
+ defer written.deinit();
+ while (core.nextEffect()) |effect| {
+ if (effect == .write) try written.writer.writeAll(effect.write.bytes.slice());
+ }
+ try std.testing.expectEqualStrings("\x1b[15~\x1b[2~\x1b[A", written.written());
+}
+
+test "the window's function and editing keys reach a terminal as its cursor keys' mode and keyboard flags say" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
+ defer core.deinit();
+ core.panes[0].?.body.mode = .tty;
+ while (core.nextEffect()) |_| {}
+ var in: Input = .{ .core = core };
+ var written: std.Io.Writer.Allocating = .init(gpa);
+ defer written.deinit();
+ const Case = struct { modes: []const u8, sym: c.SDL_Keycode, mod: c.SDL_Keymod = 0, sent: []const u8 };
+ const cases = [_]Case{
+ .{ .modes = "", .sym = c.SDLK_UP, .sent = "\x1b[A" },
+ .{ .modes = "", .sym = c.SDLK_HOME, .sent = "\x1b[H" },
+ .{ .modes = "", .sym = c.SDLK_F1, .sent = "\x1bOP" },
+ .{ .modes = "", .sym = c.SDLK_F5, .sent = "\x1b[15~" },
+ .{ .modes = "", .sym = c.SDLK_F12, .mod = c.SDL_KMOD_LSHIFT, .sent = "\x1b[24;2~" },
+ .{ .modes = "", .sym = c.SDLK_INSERT, .sent = "\x1b[2~" },
+ // DECCKM: less, vim, htop.
+ .{ .modes = "\x1b[?1h", .sym = c.SDLK_UP, .sent = "\x1bOA" },
+ .{ .modes = "", .sym = c.SDLK_END, .sent = "\x1bOF" },
+ .{ .modes = "", .sym = c.SDLK_LEFT, .mod = c.SDL_KMOD_LCTRL, .sent = "\x1b[1;5D" },
+ // codex's kitty flags (>7u): Ctrl-C and Alt-a are unambiguous.
+ // (A bare Escape at a shell prompt is pardes's way out of raw input.)
+ .{ .modes = "\x1b[?1l\x1b[>7u", .sym = 'c', .mod = c.SDL_KMOD_LCTRL, .sent = "\x1b[99;5u" },
+ .{ .modes = "", .sym = 'a', .mod = c.SDL_KMOD_LALT, .sent = "\x1b[97;3u" },
+ // With event types asked for (2), an arrow says it is a press, as
+ // ghostty says it.
+ .{ .modes = "", .sym = c.SDLK_UP, .sent = "\x1b[1;1:1A" },
+ };
+ for (cases) |case| {
+ core.update(.{ .output = .{ .pane = 0, .bytes = case.modes } });
+ while (core.nextEffect()) |_| {}
+ keyDown(&in, case.sym, case.mod);
+ written.clearRetainingCapacity();
+ while (core.nextEffect()) |effect| {
+ if (effect == .write) try written.writer.writeAll(effect.write.bytes.slice());
+ }
+ try std.testing.expectEqualStrings(case.sent, written.written());
+ }
+}
+
const Input = struct {
core: ?*pardes.Pardes = null,
client: ?*detached_client.Client = null,
@@ -2991,7 +3134,7 @@ const Input = struct {
const client = in.client orelse return;
if (in.lost != null) return;
client.send(.{ .event = ev }) catch |err| switch (err) {
- error.Overlong, error.NoSpace => {},
+ error.Overlong, error.WriteFailed => {},
else => in.lost = err,
};
}
@@ -3003,8 +3146,39 @@ const Input = struct {
};
fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
+ // An input's time, for its latency to the frame that answers it
+ // (FrameStats): SDL's stamp, moved onto the monotonic clock.
+ switch (sev.type) {
+ c.SDL_EVENT_KEY_DOWN, c.SDL_EVENT_TEXT_INPUT, c.SDL_EVENT_MOUSE_BUTTON_DOWN, c.SDL_EVENT_MOUSE_WHEEL => {
+ g.input_seen = true;
+ if (frame_probe) |probe| probe.input(monoNs() -| (c.SDL_GetTicksNS() -| sev.common.timestamp));
+ },
+ else => {},
+ }
+ // What the post chain sees of the pointer and the focus.
+ switch (sev.type) {
+ c.SDL_EVENT_MOUSE_MOTION => {
+ const at = windowPointToPixels(windowGeometry(g.window), sev.motion.x, sev.motion.y);
+ g.post.mouse(at.x, at.y, null);
+ },
+ c.SDL_EVENT_MOUSE_BUTTON_DOWN, c.SDL_EVENT_MOUSE_BUTTON_UP => {
+ const at = windowPointToPixels(windowGeometry(g.window), sev.button.x, sev.button.y);
+ g.post.mouse(at.x, at.y, sev.button.down);
+ },
+ c.SDL_EVENT_WINDOW_DISPLAY_SCALE_CHANGED => {
+ updateDisplayScale(g.window);
+ // Underlines are drawn into the glyphs a logical pixel thick.
+ resetGlyphAtlas(g);
+ if (in.core) |core| core.needs_frame = true;
+ },
+ c.SDL_EVENT_WINDOW_FOCUS_GAINED => g.post.focus(true),
+ c.SDL_EVENT_WINDOW_FOCUS_LOST => g.post.focus(false),
+ else => {},
+ }
switch (sev.type) {
c.SDL_EVENT_QUIT, c.SDL_EVENT_WINDOW_CLOSE_REQUESTED => in.close(),
+ c.SDL_EVENT_WINDOW_FOCUS_GAINED => in.post(.{ .focus = true }),
+ c.SDL_EVENT_WINDOW_FOCUS_LOST => in.post(.{ .focus = false }),
c.SDL_EVENT_WINDOW_MOUSE_LEAVE => {
g.pointer_present = false;
g.pointer_mapped = false;
@@ -3074,17 +3248,12 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
};
g.pointer_mapped = true;
g.pointer_cell = mc;
- in.post(.{
- .mouse = .{
- .button = button,
- .kind = if (b.down) .press else .release,
- .col = mc.col,
- .row = mc.row,
- .tag_hit = mc.tag_hit,
- .body_hit = mc.body_hit,
- .ctrl = (c.SDL_GetModState() & c.SDL_KMOD_CTRL) != 0,
- },
- });
+ var ev = pointerMouse(button, if (b.down) .press else .release, mc, pointerMods());
+ // Let go past the window's edge (SDL follows a held button out
+ // of the window: Wayland's implicit grab, X11's capture).
+ const win = windowGeometry(g.window);
+ ev.outside = !b.down and (b.x < 0 or b.y < 0 or b.x >= win.window_w or b.y >= win.window_h);
+ in.post(.{ .mouse = ev });
},
c.SDL_EVENT_MOUSE_MOTION => {
const m = sev.motion;
@@ -3106,14 +3275,7 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
};
g.pointer_mapped = true;
g.pointer_cell = mc;
- in.post(.{ .mouse = .{
- .button = held orelse .none,
- .kind = if (held != null) .drag else .motion,
- .col = mc.col,
- .row = mc.row,
- .tag_hit = mc.tag_hit,
- .body_hit = mc.body_hit,
- } });
+ in.post(.{ .mouse = pointerMouse(held orelse .none, if (held != null) .drag else .motion, mc, pointerMods()) });
},
c.SDL_EVENT_MOUSE_WHEEL => {
const w = sev.wheel;
@@ -3128,54 +3290,11 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
};
g.pointer_mapped = true;
g.pointer_cell = mc;
- if (w.y != 0 and std.math.isFinite(w.y)) {
- if (in.core) |core| {
- const hit: ?usize = for (core.panes, 0..) |slot, i| {
- if (slot == null) continue;
- const r = core.rects[i];
- if (mc.col >= r.x and mc.col < r.x + r.w and mc.row >= r.y and mc.row < r.y + r.h) break i;
- } else null;
- if (g.scroll_pane) |old| if (hit == null or hit.? != old) {
- resetScroll(g);
- };
- if (hit) |id| {
- const pdf_target = if (comptime pardes.pdf_enabled)
- core.native_images and core.panes[id].?.pdfPage() != null
- else
- false;
- if (pdf_target) {
- resetScroll(g);
- in.post(.{ .pdf_scroll = .{
- .pane = @intCast(id),
- .delta_pixels = -w.y * @as(f32, @floatFromInt(g.cell_h)),
- } });
- } else {
- g.scroll_pane = id;
- g.scroll_col = mc.col;
- g.scroll_row = mc.row;
- g.scroll_delta = accumulateWheelDelta(g.scroll_delta, w.y);
- }
- }
- } else {
- g.scroll_delta = accumulateWheelDelta(g.scroll_delta, w.y);
- while (g.scroll_delta >= 1) : (g.scroll_delta -= 1)
- in.post(.{ .mouse = .{ .button = .wheel_down, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit } });
- while (g.scroll_delta <= -1) : (g.scroll_delta += 1)
- in.post(.{ .mouse = .{ .button = .wheel_up, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit } });
- }
- }
- if (w.x != 0) in.post(.{ .mouse = .{
- .button = if (w.x > 0) .wheel_right else .wheel_left,
- .kind = .press,
- .col = mc.col,
- .row = mc.row,
- .tag_hit = mc.tag_hit,
- .body_hit = mc.body_hit,
- } });
+ wheelAt(g, in, .{ .x = w.x, .y = w.y, .integer_y = w.integer_y, .mods = pointerMods() }, mc);
},
c.SDL_EVENT_FINGER_DOWN, c.SDL_EVENT_FINGER_MOTION, c.SDL_EVENT_FINGER_UP, c.SDL_EVENT_FINGER_CANCELED => {
const f = sev.tfinger;
- var finger: Finger = .{
+ const finger: Finger = .{
.kind = switch (sev.type) {
c.SDL_EVENT_FINGER_DOWN => .down,
c.SDL_EVENT_FINGER_MOTION => .motion,
@@ -3194,15 +3313,7 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
const win_h: f32 = @floatFromInt(@max(ph, 1));
const fcw: f32 = @floatFromInt(g.cell_w);
const fch: f32 = @floatFromInt(g.cell_h);
- if (mapScenePoint(g, finger.x * win_w, finger.y * win_h, win_w, win_h)) |m| {
- finger.x = m.x / win_w;
- finger.y = m.y / win_h;
- handleFinger(&g.touch, in, finger, win_w, win_h, fcw, fch, @floatFromInt(g.tagline_width));
- } else {
- finger.kind = .cancel;
- handleFinger(&g.touch, in, finger, win_w, win_h, fcw, fch, @floatFromInt(g.tagline_width));
- in.post(.pointer_leave);
- }
+ handleFinger(&g.touch, in, finger, win_w, win_h, fcw, fch, @floatFromInt(g.tagline_width));
},
c.SDL_EVENT_PINCH_BEGIN, c.SDL_EVENT_PINCH_UPDATE => in.post(.{ .pinch = sev.pinch.scale }),
c.SDL_EVENT_GAMEPAD_ADDED => {
@@ -3331,10 +3442,7 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
.cap_n => .{ .cp = 'N', .text = "N" },
.enter => .{ .cp = pardes.Key.enter },
.tab => .{ .cp = pardes.Key.tab },
- .tty_toggle => if (in.core) |core|
- .{ .cp = core.opts.tty_toggle, .ctrl = true }
- else
- .{ .cp = config.tty_toggle_alt[0].cp, .shift = true },
+ .tty_toggle => .{ .cp = if (in.core) |core| core.opts.tty_toggle else config.tty_toggle_default, .ctrl = true },
},
}),
.rumble => if (g.gamepad) |pad| {
@@ -3365,6 +3473,13 @@ fn keyDown(in: *Input, sym: c.SDL_Keycode, mod: c.SDL_Keymod) void {
c.SDLK_PAGEUP => pardes.Key.page_up,
c.SDLK_PAGEDOWN => pardes.Key.page_down,
c.SDLK_DELETE => pardes.Key.delete,
+ c.SDLK_INSERT => pardes.Key.insert,
+ c.SDLK_PRINTSCREEN => pardes.Key.print_screen,
+ c.SDLK_SCROLLLOCK => pardes.Key.scroll_lock,
+ c.SDLK_PAUSE => pardes.Key.pause,
+ c.SDLK_APPLICATION => pardes.Key.menu,
+ c.SDLK_F1...c.SDLK_F12 => pardes.Key.f1 + @as(u21, @intCast(sym - c.SDLK_F1)),
+ c.SDLK_F13...c.SDLK_F24 => pardes.Key.f1 + 12 + @as(u21, @intCast(sym - c.SDLK_F13)),
else => blk: {
if (!(ctrl or alt or gui_mod)) break :blk 0;
if (sym < 128 and sym >= ' ') break :blk @intCast(sym);
@@ -3390,9 +3505,11 @@ fn gridCellAtDimensions(
) MouseCell {
const row: u16 = @intFromFloat(@min(@floor(@max(y, 0) / @max(body_h, 1)), 10_000));
var point: MouseCell = .{ .col = @intFromFloat(@min(@floor(@max(x, 0) / @max(body_w, 1)), 10_000)), .row = row };
+ // On the rule over this row, which is where two panes meet if they do.
+ point.rule_above = row > 0 and @max(y, 0) - @as(f32, @floatFromInt(row)) * @max(body_h, 1) < dp(rule_grab_px);
if (core) |p| if (p.presentation.pointerFractional(p.screen_w, p.screen_h, x / @max(body_w, 1), y / @max(body_h, 1))) |mapped| {
for (p.surface.tagLayers()) |*layer| {
- if (layer.hitAt(mapped.x * body_w, mapped.y * body_h, body_w, body_h, tagline_w, @floatFromInt(p.row_metrics.tagline_h))) |hit| {
+ if (layer.tagHit(mapped.x * body_w, mapped.y * body_h, body_w, body_h, tagline_w, @floatFromInt(p.row_metrics.tagline_h))) |hit| {
point.tag_hit = hit;
break;
}
@@ -3404,19 +3521,19 @@ fn gridCellAtDimensions(
fn gridCellAtPixels(g: *const Gui, core: ?*const pardes.Pardes, x: f32, y: f32) MouseCell {
var point = gridCellAtDimensions(core, x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width));
if (core) |p| if (p.presentation.pointerFractional(p.screen_w, p.screen_h, x / @as(f32, @floatFromInt(g.cell_w)), y / @as(f32, @floatFromInt(g.cell_h)))) |mapped| for (p.surface.bodyLayers()) |*layer| {
- if (layer.hitAt(mapped.x * @as(f32, @floatFromInt(g.cell_w)), mapped.y * @as(f32, @floatFromInt(g.cell_h)), @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |hit| {
+ if (layer.bodyHit(mapped.x * @as(f32, @floatFromInt(g.cell_w)), mapped.y * @as(f32, @floatFromInt(g.cell_h)), @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |hit| {
point.body_hit = hit;
break;
}
};
if (core == null) if (g.attached_layers) |layers| for (layers) |*layer| {
- if (layer.hitAt(x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |body_hit| {
+ if (layer.bodyHit(x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |body_hit| {
point.body_hit = body_hit;
break;
}
};
if (core == null) if (g.attached_tag_layers) |layers| for (layers) |*layer| {
- if (layer.hitAt(x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |hit| {
+ if (layer.tagHit(x, y, @floatFromInt(g.cell_w), @floatFromInt(g.cell_h), @floatFromInt(g.tagline_width), @floatFromInt(g.tagline_height))) |hit| {
point.tag_hit = hit;
break;
}
@@ -3451,9 +3568,10 @@ test "tagline pointer mapping retains physical grips and carries logical text co
try std.testing.expect(grip.tag_hit == null);
try std.testing.expectEqual(r.x + config.GUTTER - 1, grip.col);
- const body = gridCellAtDimensions(core, x, (@as(f32, @floatFromInt(tag_y + 1)) + 0.5) * body_h, body_w, body_h, tag_w);
+ const body_y = tag_y + core.panes[core.active].?.tag_rows; // a long tag wraps
+ const body = gridCellAtDimensions(core, x, (@as(f32, @floatFromInt(body_y)) + 0.5) * body_h, body_w, body_h, tag_w);
try std.testing.expectEqual(pixelCell(x, 10), body.col);
- try std.testing.expectEqual(tag_y + 1, body.row);
+ try std.testing.expectEqual(body_y, body.row);
try std.testing.expect(body.tag_hit == null);
const topbar = gridCellAtDimensions(core, 3.5 * tag_w, 0.5 * body_h, body_w, body_h, tag_w);
@@ -3462,20 +3580,145 @@ test "tagline pointer mapping retains physical grips and carries logical text co
try std.testing.expectEqual(pardes.TagKind.workspace, topbar.tag_hit.?.kind);
}
-fn mapScenePoint(g: *const Gui, x: f32, y: f32, w: f32, h: f32) ?crt.Point {
- return crt.mapScene(x, y, w, h, g.presented_scene.effects, g.presented_scene.time_seconds);
+test "a click at the window's corner lands in the corner cell with a post chain on" {
+ const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ try std.testing.expect(core.settings.post.set(.crt, "", true));
+ var g: Gui = undefined;
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ const geometry: WindowGeometry = .{ .window_w = 400, .window_h = 240, .pixel_w = 800, .pixel_h = 480 };
+ const last = mouseCellWithGeometry(&g, core, 399.9, 239.9, geometry).?;
+ try std.testing.expectEqual(@as(u16, 79), last.col);
+ try std.testing.expectEqual(@as(u16, 23), last.row);
+ const first = mouseCellWithGeometry(&g, core, 0, 0, geometry).?;
+ try std.testing.expectEqual(@as(u16, 0), first.col);
+ try std.testing.expectEqual(@as(u16, 0), first.row);
+}
+
+/// Where a window point lands: the cell drawn under it. Input is identity:
+/// no post pass moves a pixel (the bundled Crt has no barrel), so a click
+/// is exactly where it looks.
+/// A wheel turned over grid cell `mc` (SDL's sign: up positive): the
+/// part of dispatch after the pointer is placed, so a test can turn it.
+fn wheelAt(g: *Gui, in: *Input, w: WheelTurn, mc: MouseCell) void {
+ if (w.y != 0 and std.math.isFinite(w.y)) {
+ if (in.core) |core| {
+ const hit: ?usize = for (core.panes, 0..) |slot, i| {
+ if (slot == null) continue;
+ const r = core.rects[i];
+ if (mc.col >= r.x and mc.col < r.x + r.w and mc.row >= r.y and mc.row < r.y + r.h) break i;
+ } else null;
+ if (g.scroll_pane) |old| if (hit == null or hit.? != old) {
+ resetScroll(g);
+ };
+ if (hit) |id| {
+ const pdf_target = if (comptime pardes.pdf_enabled)
+ core.native_images and core.panes[id].?.pdfPage() != null
+ else
+ false;
+ const pane = core.panes[id].?;
+ if (pdf_target) {
+ resetScroll(g);
+ in.post(.{ .pdf_scroll = .{
+ .pane = @intCast(id),
+ .delta_pixels = -w.y * @as(f32, @floatFromInt(g.cell_h)),
+ .glide = notchOf(w.y, w.integer_y) != null,
+ } });
+ } else if (!w.mods.shift and pane.isTerminal() and pardes.panes.terminal.ownsWheel(pane)) {
+ // The program's (codex, htop, less): every whole
+ // turn goes to it, no glide, for nothing of ours
+ // moves. Shift keeps the wheel pardes's.
+ resetScroll(g);
+ g.program_wheel = accumulateWheelDelta(g.program_wheel, w.y);
+ while (g.program_wheel >= 1) : (g.program_wheel -= 1)
+ in.post(.{ .mouse = .{ .button = .wheel_down, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit, .ctrl = w.mods.ctrl, .shift = w.mods.shift, .alt = w.mods.alt } });
+ while (g.program_wheel <= -1) : (g.program_wheel += 1)
+ in.post(.{ .mouse = .{ .button = .wheel_up, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit, .ctrl = w.mods.ctrl, .shift = w.mods.shift, .alt = w.mods.alt } });
+ } else {
+ g.scroll_pane = id;
+ g.scroll_col = mc.col;
+ g.scroll_row = mc.row;
+ // A mouse wheel's notch is a whole line and
+ // glides (G6); a touchpad's fraction moves the
+ // picture by itself, under the finger.
+ if (notchOf(w.y, w.integer_y)) |lines| {
+ g.scroll_notch +|= lines;
+ } else g.scroll_delta = accumulateWheelDelta(g.scroll_delta, w.y);
+ }
+ }
+ } else {
+ g.scroll_delta = accumulateWheelDelta(g.scroll_delta, w.y);
+ while (g.scroll_delta >= 1) : (g.scroll_delta -= 1)
+ in.post(.{ .mouse = .{ .button = .wheel_down, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit, .ctrl = w.mods.ctrl, .shift = w.mods.shift, .alt = w.mods.alt } });
+ while (g.scroll_delta <= -1) : (g.scroll_delta += 1)
+ in.post(.{ .mouse = .{ .button = .wheel_up, .kind = .press, .col = mc.col, .row = mc.row, .tag_hit = mc.tag_hit, .body_hit = mc.body_hit, .ctrl = w.mods.ctrl, .shift = w.mods.shift, .alt = w.mods.alt } });
+ }
+ }
+ if (w.x != 0) in.post(.{ .mouse = .{
+ .button = if (w.x > 0) .wheel_right else .wheel_left,
+ .kind = .press,
+ .col = mc.col,
+ .row = mc.row,
+ .tag_hit = mc.tag_hit,
+ .body_hit = mc.body_hit,
+ .ctrl = w.mods.ctrl,
+ .shift = w.mods.shift,
+ .alt = w.mods.alt,
+ } });
+}
+
+const WheelTurn = struct { x: f32 = 0, y: f32 = 0, integer_y: i32 = 0, mods: PointerMods = .{} };
+
+/// The modifiers held with a pointer event, as the core's Mouse carries them.
+const PointerMods = struct { ctrl: bool = false, shift: bool = false, alt: bool = false, super: bool = false };
+
+/// The core's Mouse for an SDL press, release or move over cell `mc`.
+fn pointerMouse(button: pardes.Mouse.Button, kind: pardes.Mouse.Kind, mc: MouseCell, mods: PointerMods) pardes.Mouse {
+ return .{
+ .button = button,
+ .kind = kind,
+ .col = mc.col,
+ .row = mc.row,
+ .tag_hit = mc.tag_hit,
+ .body_hit = mc.body_hit,
+ .rule_above = (kind == .press or kind == .release) and mc.rule_above,
+ .ctrl = mods.ctrl,
+ .shift = mods.shift,
+ .alt = mods.alt,
+ .super = mods.super,
+ };
+}
+
+fn pointerMods() PointerMods {
+ const m = c.SDL_GetModState();
+ return .{ .ctrl = (m & c.SDL_KMOD_CTRL) != 0, .shift = (m & c.SDL_KMOD_SHIFT) != 0, .alt = (m & c.SDL_KMOD_ALT) != 0, .super = (m & c.SDL_KMOD_GUI) != 0 };
}
fn mouseCellWithGeometry(g: *const Gui, core: ?*const pardes.Pardes, x: f32, y: f32, geometry: WindowGeometry) ?MouseCell {
const physical = windowPointToPixels(geometry, x, y);
- const mapped = mapScenePoint(g, physical.x, physical.y, geometry.pixel_w, geometry.pixel_h) orelse return null;
- return gridCellAtPixels(g, core, mapped.x, mapped.y);
+ return gridCellAtPixels(g, core, physical.x, physical.y);
}
fn mouseCell(g: *const Gui, core: ?*const pardes.Pardes, x: f32, y: f32) ?MouseCell {
return mouseCellWithGeometry(g, core, x, y, windowGeometry(g.window));
}
+/// SDL's hit test, asked as the pointer moves over the window: a blank cell
+/// of the workspace tag (tagline.workspaceBlank) is the window's to drag, as
+/// a title bar is. SDL gives the compositor a B1 press there (Wayland's
+/// xdg_toplevel.move, X11's _NET_WM_MOVERESIZE, macOS's own drag), so the
+/// press never reaches the core; B2 and B3 there still do.
+fn hitTest(_: ?*c.SDL_Window, area: [*c]const c.SDL_Point, data: ?*anyopaque) callconv(.c) c.SDL_HitTestResult {
+ const g: *Gui = @ptrCast(@alignCast(data orelse return c.SDL_HITTEST_NORMAL));
+ const core = g.hit_core orelse return c.SDL_HITTEST_NORMAL;
+ if (area == null) return c.SDL_HITTEST_NORMAL;
+ const mc = mouseCell(g, core, @floatFromInt(area.*.x), @floatFromInt(area.*.y)) orelse return c.SDL_HITTEST_NORMAL;
+ return if (pardes.tagline.workspaceBlank(core, mc.col, mc.row, mc.tag_hit)) c.SDL_HITTEST_DRAGGABLE else c.SDL_HITTEST_NORMAL;
+}
+
fn heldPointerButton(g: *const Gui) ?pardes.Mouse.Button {
const buttons = c.SDL_GetMouseState(null, null);
if ((buttons & c.SDL_BUTTON_LMASK) != 0 or g.deck.r2_held or g.deck.rpad_click) return .left;
@@ -3571,43 +3814,57 @@ const Shell = struct {
ptys: *[pardes.MAX_PANES]?Pty,
gens: *[pardes.MAX_PANES]u32,
queue: *Queue,
+ /// What drainQueue takes each wakeup, kept rather than rebuilt.
+ batch: MessageBatch = .{},
pipe_tasks: *PipeTasks,
inotify_fd: c_int,
watches: *file_watch.Table,
+ /// The post chain's files as SPIR-V.
+ shaders: ShaderBuild = .{},
threads_ok: bool = false,
test_mode: bool = false,
feed: StdinFeed = .{},
presented: bool = false,
+ skipped_presents: u8 = 0,
surface: ?*pardes.Surface = null,
- animation_clock: AnimationClock = .{},
saw_event: bool = false,
dump_err: ?anyerror = null,
retired_shells: [pardes.MAX_PANES]RetiredShell = @splat(.{}),
+ /// PARDES_TEST_CLOCK's virtual time (host_io.testClock), in test mode.
+ test_clock: ?u64 = null,
+ /// The display rate a virtual clock stands in for (PARDES_TEST_HZ).
+ test_hz: u64 = 60,
+ /// The tick a paced frame is sampled at (waitInput): the clock the
+ /// core is advanced to while anything moves.
+ paced_ns: ?u64 = null,
fn reap(s: *Shell) void {
- const now = shellClock();
- for (&s.retired_shells) |*child| reapShell(&child.pid, &child.kill_at, now);
+ const now = std.Io.Clock.awake.now(s.queue.io).toMilliseconds();
+ for (&s.retired_shells) |*child| host_io.reapRetired(&child.pid, &child.kill_at, now);
for (s.ptys) |*slot| if (slot.*) |*pt| if (pt.fd < 0) {
- reapShell(&pt.pid, &pt.kill_at, now);
+ host_io.reapRetired(&pt.pid, &pt.kill_at, now);
if (pt.pid == 0) slot.* = null;
};
}
+ fn closePaneShell(ctx: ?*anyopaque, pane: u8) void {
+ shellOf(ctx).closePty(pane);
+ }
+
fn closePty(s: *Shell, pane: u8) void {
const pt = if (s.ptys[pane]) |*pt| pt else return;
if (pt.fd < 0) return;
+ // Out of the queue first, which lets go a reader waiting for room
+ // in it; then its read is canceled (or, at its end, it is joined).
s.queue.cancelReader(pane, s.gens[pane]);
- if (pt.reader) |thread| {
- _ = host_io.writeFd(pt.stop[1], "x");
- thread.join();
+ if (pt.reader) |*reader| {
+ reader.cancel(s.queue.io); // the Io it was started on (startReader)
pt.reader = null;
- for (pt.stop) |fd| _ = libc.close(fd);
- pt.stop = .{ -1, -1 };
}
_ = libc.close(pt.fd);
pt.fd = -1;
- const now = shellClock();
- reapShell(&pt.pid, &pt.kill_at, now);
+ const now = std.Io.Clock.awake.now(s.queue.io).toMilliseconds();
+ host_io.reapRetired(&pt.pid, &pt.kill_at, now);
if (pt.pid == 0) {
s.ptys[pane] = null;
return;
@@ -3619,6 +3876,10 @@ const Shell = struct {
s.ptys[pane] = null;
return;
};
+ // No room to wait for it here: a slot kept for it would refuse the
+ // next shell spawned into this pane until it was reaped.
+ host_io.retireShell(pt.pid);
+ s.ptys[pane] = null;
}
fn stopPtys(s: *Shell) void {
@@ -3661,6 +3922,7 @@ const Shell = struct {
const vtable: pardes.Host.VTable = .{
.wait_input = waitInput,
+ .now = guiNow,
.present = present,
.post_present = postPresent,
.poll_frame = pollFrame,
@@ -3668,7 +3930,10 @@ const Shell = struct {
.pty_write = ptyWrite,
.pty_resize = ptyResize,
.pty_signal = ptySignal,
+ .close_pty = closePaneShell,
.tty_taken = ttyTaken,
+ .fg_name = fgName,
+ .kill_job = killJob,
.write_file = writeFile,
.write_dump = writeDump,
.watch_file = watchFile,
@@ -3679,11 +3944,14 @@ const Shell = struct {
.open_link = openLink,
.lsp = lsp,
.pipe = pipe,
+ .search = search,
+ .hand_over = handOver,
};
const grid_vtable: pardes.Host.VTable = vt: {
var v = vtable;
v.wait_input = null;
+ v.now = null;
v.poll_frame = gridPollFrame;
v.present = gridPresent;
v.post_present = gridPostPresent;
@@ -3692,9 +3960,22 @@ const Shell = struct {
break :vt v;
};
+ /// The command panes' exits, told once their output is in (host_io).
+ fn takeExits(s: *Shell) void {
+ host_io.takeExits(s.core, s.ptys, s, closeWatched);
+ }
+
+ fn closeWatched(s: *Shell, id: usize) void {
+ s.closePty(@intCast(id));
+ s.saw_event = true;
+ }
+
fn drainQueue(s: *Shell) void {
s.reconcilePtys();
- var msgs = s.queue.take();
+ // After this batch's output, which an exit is told behind.
+ defer s.takeExits();
+ s.queue.takeInto(&s.batch);
+ const msgs = &s.batch;
var check_files = false;
for (msgs.slice()) |m| switch (m) {
.output => |o| {
@@ -3704,14 +3985,34 @@ const Shell = struct {
s.saw_event = true;
},
.eof => |e| {
- if (s.gens[e.pane] == e.gen) {
- s.closePty(e.pane);
+ if (s.gens[e.pane] == e.gen) eof: {
if (e.failure) |err| {
+ s.closePty(e.pane);
if (s.core.panes[e.pane]) |pane| {
- pane.mode = .normal;
+ pane.body.mode = .normal;
s.core.reportError(e.pane, "terminal reader", err);
}
- } else s.core.update(.{ .eof = .{ .pane = e.pane } });
+ break :eof;
+ }
+ const pt = if (s.ptys[e.pane]) |*pt| pt else {
+ s.core.update(.{ .eof = .{ .pane = e.pane } });
+ break :eof;
+ };
+ // A command's pty stays open until its child has exited:
+ // closing it would hang up one that runs on without it.
+ // Its exit, if it came first, is told now its output is in.
+ if (pt.cmd.watched) {
+ host_io.commandEof(s.core, s.ptys, e.pane, s, closeWatched);
+ break :eof;
+ }
+ // Unwatched, a command's exit is read here, as its end,
+ // and a shell's, for a run waiting on it and the log.
+ const unwatched = if (s.core.panes[e.pane]) |pane| pane.command != null else false;
+ const status = host_io.exitStatus(pt.pid, 100);
+ if (status != null) pt.pid = 0; // reaped: no shell to retire
+ s.closePty(e.pane);
+ if (unwatched or status != null) s.core.update(.{ .exited = .{ .pane = e.pane, .status = status } });
+ s.core.update(.{ .eof = .{ .pane = e.pane } });
}
s.saw_event = true;
},
@@ -3738,14 +4039,32 @@ const Shell = struct {
s.saw_event = true;
s.pipe_tasks.finish(s.io, response_value.id);
},
+ .search => |b| {
+ s.core.update(.{ .search = b });
+ b.deinit(s.gpa);
+ s.saw_event = true;
+ },
+ .handed => |h| {
+ s.core.update(.{ .handed = .{ .seq = h.seq, .to = if (h.ok) h.words else "", .failure = if (h.ok) null else h.words } });
+ s.gpa.free(h.words);
+ s.saw_event = true;
+ },
.files_changed => check_files = true,
.fs_ready => {},
};
+ if (check_files) s.shaders.recheck();
if (check_files and file_watch.reloadChanged(s.core, s.io, s.gpa, s.watches))
s.queue.push(.files_changed);
}
};
+/// A post chain compile is done (ShaderBuild.zig): the loop's SDL wait ends.
+fn wakeSdl(_: ?*anyopaque) void {
+ var event = std.mem.zeroes(c.SDL_Event);
+ event.type = c.SDL_EVENT_USER;
+ _ = c.SDL_PushEvent(&event);
+}
+
fn wakeFs(ctx: ?*anyopaque) void {
const q: *Queue = @ptrCast(@alignCast(ctx.?));
q.push(.fs_ready);
@@ -3761,11 +4080,140 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
var in: Input = .{ .core = core };
if (s.gui) |g| {
var sev = std.mem.zeroes(c.SDL_Event);
- const ms: c_int = if (timeout_ms != 0) @intCast(timeout_ms) else 16;
- if (c.SDL_WaitEventTimeout(&sev, ms)) {
- dispatch(g, &in, &sev);
- while (c.SDL_PollEvent(&sev)) dispatch(g, &in, &sev);
+ // Idle is asleep until an event: SDL's own, and the user events the
+ // shell's queue raises for a terminal's output, a completion, a file
+ // system request. What the shell moves or times itself polls every
+ // frame: a smooth scroll, a gamepad's sticks, the test stdin feed,
+ // a post chain that moves on its own (ShaderAnimation),
+ // a retired shell waiting to be killed, a present to retry. A
+ // minimized window sleeps through the core's animation too: nothing
+ // shows it, and it is caught up at once when the window is back.
+ const retiring = for (s.retired_shells) |child| {
+ if (child.kill_at != 0) break true;
+ } else for (s.ptys) |slot| {
+ if (slot) |pt| if (pt.kill_at != 0) break true;
+ } else false;
+ const polls = g.scroll_lag != 0 or g.scroll_delta != 0 or g.scroll_notch != 0 or g.glide.moving() or g.gamepad != null or s.test_mode or core.needs_frame or retiring or
+ g.post.animating(core.settings.shader_animation);
+ const minimized = !s.test_mode and c.SDL_GetWindowFlags(g.window) & (c.SDL_WINDOW_MINIMIZED | c.SDL_WINDOW_OCCLUDED) != 0;
+ // A latency trace is fed on stdin, whose poll below paces the loop:
+ // waiting here too would make every tick cost two frames.
+ // A chain that moves on its own wakes once a display refresh.
+ const poll_ms: c_int = if (g.post.animating(core.settings.shader_animation))
+ @intCast(@max(1, refreshNs(g) / std.time.ns_per_ms))
+ else
+ 16;
+ const waited: c_int = if (latency_fd >= 0) 0 else if (minimized) -1 else if (timeout_ms != 0) @min(@as(c_int, @intCast(@min(timeout_ms, std.math.maxInt(c_int)))), if (polls) poll_ms else std.math.maxInt(c_int)) else if (polls) poll_ms else -1;
+ // The cursor's blink is the shell's to time (Chrome.cursor_idle_ms):
+ // a frame a loop through an edge, else a wake at the next one; none
+ // while the window is minimized or unfocused. A virtual clock never
+ // blinks, so goldens hold still.
+ const blink = if (s.test_clock != null or minimized) null else blinkNow(g, if (s.surface) |frame| &frame.chrome else null);
+ const blink_ms: ?c_int = if (blink) |b| (if (b.edge) 1 else if (b.next_ns) |next| @as(c_int, @intCast(@min(std.math.maxInt(c_int), next / std.time.ns_per_ms + 1))) else null) else null;
+ const blinked: c_int = if (blink_ms) |b| (if (waited < 0) b else @min(waited, b)) else waited;
+ // The timedemo's next step is a wake too.
+ var ms: c_int = if (demoDue(g)) |due| (if (blinked < 0) due else @min(blinked, due)) else blinked;
+ // While anything moves, frames are paced as a game's are: one a
+ // display refresh, on a grid of ticks a period apart, each sampled
+ // at its tick (guiNow), however early or late the loop got there.
+ // Input that comes between two ticks is acted on as it comes (the
+ // core's state is never held back) and drawn at the next tick. Not
+ // paced, the loop ran as fast as it could present (the soft present
+ // has no vsync), ~230 frames a second on a 60 Hz display, and the
+ // compositor showed whichever was newest at each refresh: motion
+ // sampled at random phase, uneven steps, a judder in every scroll.
+ // ponytail: the period is the display mode's refresh and the grid's
+ // phase is our own, not the display's (no vblank time to read on the
+ // soft present); a 59.94 Hz display drifts a tick every 17 s. The
+ // upgrade: the presentation feedback protocol's timestamps.
+ const paced = s.test_clock == null and latency_fd < 0 and !s.test_mode and !minimized and core.continuous();
+ var tick: u64 = 0;
+ if (paced) {
+ const period = refreshNs(g);
+ const now = c.SDL_GetTicksNS();
+ // A motion from rest draws at once; one under way, at its next
+ // tick, skipping (never bunching) the ticks a slow frame missed.
+ tick = if (g.pace_ns != 0 and now -| g.pace_ns < 2 * period) g.pace_ns + period else now;
+ if (tick < now) tick += (now - tick) / period * period;
+ // Waited out polling, below.
+ ms = 0;
+ }
+ g.input_seen = false;
+ // The wait is the 9P connections' turn with the core.
+ pardes.turn.rest();
+ const got = c.SDL_WaitEventTimeout(&sev, ms);
+ pardes.turn.wake();
+ // A virtual clock: while a render-time animation moves, each loop
+ // is a presented frame and moves it by one display frame
+ // (PARDES_TEST_HZ), events or not, as a real display's present
+ // would; otherwise a wait that ran out moves it exactly to the
+ // core's wake.
+ // Through an edge, or woken for the next: the shell redraws the last
+ // frame with the new alpha, no core render (§5.5 level B).
+ if (blink_ms != null and (blink.?.edge or !got)) g.blink_due = true;
+ if (s.test_clock) |*virtual| {
+ if (core.continuous()) {
+ const display = virtual.* + std.time.ns_per_s / s.test_hz;
+ virtual.* = if (core.nextWake()) |due| @max(virtual.*, @min(due, display)) else display;
+ } else if (timeout_ms != 0 and (!got or !core.needs_frame)) {
+ // A wait that ran out, or one a stray event cut short while
+ // nothing owes a frame: time moves to the core's wake all
+ // the same, so a steady trickle of events (a pty's, the
+ // test feed's) cannot hold a virtual clock still forever.
+ virtual.* = @max(virtual.*, core.nextWake() orelse virtual.*);
+ }
+ }
+ if (got) {
+ // A run of queued motions is one move to its last position (the
+ // handler reads only absolute x/y and held buttons): acting on
+ // each would repeat hover and selection work the next undoes.
+ var motion: ?c.SDL_Event = null;
+ while (true) {
+ if (sev.type == c.SDL_EVENT_MOUSE_MOTION) {
+ motion = sev;
+ } else {
+ if (motion) |*m| dispatch(g, &in, m);
+ motion = null;
+ dispatch(g, &in, &sev);
+ }
+ if (!c.SDL_PollEvent(&sev)) break;
+ }
+ if (motion) |*m| dispatch(g, &in, m);
+ }
+ runDemo(g, &in, core);
+ // Paced: what came before the tick is in; wait out the rest of it,
+ // unless an input came: its frame is drawn at once (the paced loop
+ // never adds a tick to an input's latency), and the ticks after it
+ // run from it. A stream's repeat too: the picture it moves is on
+ // the stream's straight line wherever it is sampled, so drawing it
+ // between two ticks costs no evenness, and holding it to the tick
+ // cost a held key 7 ms of latency.
+ if (paced and g.input_seen) tick = c.SDL_GetTicksNS();
+ // The tick is waited out polling, not asleep, as a game's frame
+ // limiter spins: asleep between 60 Hz frames, the CPU's clock fell
+ // (intel_pstate, 4.9 GHz down toward 0.8) and every frame, an
+ // input's first among them, took 2-5x as long: input-to-present p50
+ // 1.9 ms spinning against 7-8 ms asleep (docs/next-anim.md).
+ // ponytail: a core while something moves (~250 ms a scroll); a
+ // sleep to a millisecond short of the tick if the power matters more.
+ while (paced and !g.input_seen) {
+ if (tick -| c.SDL_GetTicksNS() < 50 * std.time.ns_per_us) break;
+ pardes.turn.rest();
+ const more = c.SDL_PollEvent(&sev);
+ pardes.turn.wake();
+ if (more) {
+ dispatch(g, &in, &sev);
+ while (c.SDL_PollEvent(&sev)) dispatch(g, &in, &sev);
+ } else {
+ // The events asked for every 100 µs, the core busy between.
+ const until = c.SDL_GetTicksNS() + 100 * std.time.ns_per_us;
+ while (c.SDL_GetTicksNS() < @min(until, tick)) std.atomic.spinLoopHint();
+ }
+ runDemo(g, &in, core);
+ if (g.input_seen) tick = c.SDL_GetTicksNS();
}
+ s.paced_ns = if (paced) tick else null;
+ if (paced) g.pace_ns = tick;
}
if (s.test_mode) {
const r = s.feed.pump(s.gpa, &in, s.gui) catch {
@@ -3785,7 +4233,7 @@ fn pollFrame(ctx: ?*anyopaque) void {
const s = shellOf(ctx);
s.reconcilePtys();
const core = s.core;
- if (s.fs) |f| if (f.tick(core).pending) s.queue.push(.fs_ready);
+ if (s.fs) |f| if (f.tick().pending) s.queue.push(.fs_ready);
const g = s.gui orelse {
if (core.settings.window_opacity_pending) {
var unchanged_opacity: u8 = 100;
@@ -3794,7 +4242,9 @@ fn pollFrame(ctx: ?*anyopaque) void {
return;
};
syncWindowOpacity(g, core);
+ core.frames.period_ns = refreshNs(g);
syncTaglineFont(g, core);
+ syncLigatures(g, core);
if (core.takeFontRequest()) |path| blk: {
const bytes = filesystem.readFile(s.gpa, path) catch {
core.rejectFont();
@@ -3820,6 +4270,144 @@ fn pollFrame(ctx: ?*anyopaque) void {
const geom = windowCells(g);
if (updateCoreResize(core, geom.cols, geom.rows, g.cell_w, g.cell_h, g.tagline_width, g.tagline_height)) resetScroll(g);
stepScroll(g, core, s.gpa);
+ _ = s.shaders.sync(s.gpa, s.io, core, s.inotify_fd, s.watches, .{ .call = wakeSdl });
+ {
+ var passes: [Post.max]ShaderBuild.Pass = undefined;
+ g.post.sync(s.gpa, g.device, g.swapchain_format, s.shaders.view(&core.settings.post, &passes), s.shaders.revision, core);
+ }
+ if (s.test_mode) writeTestStatus(g, core, s.presented);
+ // Between the core's frames, a chain that moves on its own redraws
+ // alone, once a refresh of the display the window is on (a millisecond
+ // early is on time: the wait that paces it is in whole milliseconds).
+ if (g.post.animating(core.settings.shader_animation) and !core.needs_frame and s.presented and
+ c.SDL_GetTicksNS() -| g.post.last_ns + std.time.ns_per_ms >= refreshNs(g)) redrawPost(g, s.gpa);
+ // A blink edge: the last frame again, the cursor's alpha moved on.
+ if (g.blink_due and !core.needs_frame and s.presented) if (s.surface) |frame| {
+ g.blink_due = false;
+ blink_redraws += 1;
+ s.presented = renderFrame(g, s.gpa, core, frame, core.settings.debug) catch false;
+ };
+}
+
+/// Frames drawn for a blink alone, with no core render (tests, tracing).
+var blink_redraws: u64 = 0;
+
+/// PARDES_FRAMES_CAPTURE's directory, and how many frames it has.
+var frame_capture_dir: ?[]const u8 = null;
+var frame_capture_count: u32 = 0;
+
+fn captureSeries(dir: []const u8, pixels: []const u8, w: u32, h: u32) void {
+ var path_buf: [4096]u8 = undefined;
+ const path = std.fmt.bufPrintSentinel(&path_buf, "{s}/{d:0>6}.bgra", .{ dir, frame_capture_count }, 0) catch return;
+ const fd = libc.open(path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(libc.mode_t, 0o644));
+ if (fd < 0) return;
+ _ = libc.write(fd, pixels.ptr, pixels.len);
+ _ = libc.close(fd);
+ const times = std.fmt.bufPrintSentinel(&path_buf, "{s}/times.txt", .{dir}, 0) catch return;
+ const tf = libc.open(times, .{ .ACCMODE = .WRONLY, .CREAT = true, .APPEND = true }, @as(libc.mode_t, 0o644));
+ if (tf < 0) return;
+ var line_buf: [96]u8 = undefined;
+ const line = std.fmt.bufPrint(&line_buf, "{d} {d} {d} {d}\n", .{ frame_capture_count, monoNs(), w, h }) catch "";
+ _ = libc.write(tf, line.ptr, line.len);
+ _ = libc.close(tf);
+ frame_capture_count += 1;
+}
+
+/// The core's frame probe (FrameStats), for the latency of the inputs the
+/// shell reads and the zones its own work goes in; null in tests.
+var frame_probe: ?*pardes.FrameStats = null;
+
+/// How long until the timedemo's next step, ms; null when none runs.
+fn demoDue(g: *const Gui) ?c_int {
+ const next = g.demo_next orelse return null;
+ if (g.demo_start_ns == 0 or next >= g.demo.len) return 0;
+ const at = g.demo_start_ns + @as(u64, g.demo[next].at_ms) * std.time.ns_per_ms;
+ return @intCast(@min(std.math.maxInt(c_int), (at -| monoNs()) / std.time.ns_per_ms));
+}
+
+/// PARDES_FRAMES_DEMO: the steps of FrameStats.demo whose time has come,
+/// through the paths the window's own wheel and keys take, over the
+/// focused pane's body; its clock starts at the first loop. Its end
+/// ends the session (PARDES_FRAMES has the timings then).
+fn runDemo(g: *Gui, in: *Input, core: *pardes.Pardes) void {
+ const steps = g.demo;
+ var next = g.demo_next orelse return;
+ const now = monoNs();
+ if (g.demo_start_ns == 0) {
+ g.demo_start_ns = now;
+ core.frames.demo_ns = now;
+ core.frames.demo_name = g.demo_name;
+ }
+ defer g.demo_next = next;
+ while (next < steps.len and g.demo_start_ns + @as(u64, steps[next].at_ms) * std.time.ns_per_ms <= now) : (next += 1) {
+ const r = core.rects[core.active];
+ if (steps[next].act != .phase) g.input_seen = true;
+ switch (steps[next].act) {
+ .wheel => |notches| {
+ core.frames.input(now);
+ wheelAt(g, in, .{ .y = @floatFromInt(-notches), .integer_y = -notches }, .{ .col = r.x + r.w / 2, .row = r.y + r.h / 2 });
+ },
+ .touch => |lines| {
+ core.frames.input(now);
+ wheelAt(g, in, .{ .y = -lines }, .{ .col = r.x + r.w / 2, .row = r.y + r.h / 2 });
+ },
+ .key => |key| {
+ core.frames.input(now);
+ in.post(.{ .key = key });
+ },
+ .phase => {},
+ .click => |click| {
+ core.frames.input(now);
+ const pane = core.panes[core.active] orelse continue;
+ const top = core.bodyTop(pane, r);
+ const row: u16 = top + @as(u16, @intFromFloat(click.at * @as(f32, @floatFromInt(r.h -| pane.tag_rows -| 1))));
+ const col: u16 = if (click.rail) r.x else r.x + config.GUTTER + 4;
+ for ([_]pardes.Mouse.Kind{ .press, .release }) |kind| in.post(.{ .mouse = .{ .button = click.button, .kind = kind, .col = col, .row = row } });
+ },
+ .rail_wheel => |notches| {
+ core.frames.input(now);
+ wheelAt(g, in, .{ .y = @floatFromInt(-notches), .integer_y = -notches }, .{ .col = r.x, .row = r.y + r.h / 2 });
+ },
+ .paste => |text| {
+ core.frames.input(now);
+ in.post(.{ .paste = text });
+ },
+ .exec => |line| {
+ core.frames.input(now);
+ var newest: u32 = 0;
+ for (core.panes) |slot| if (slot) |pane| {
+ newest = @max(newest, pane.serial);
+ };
+ _ = pardes.exec.executeFrom(core, core.active, line, false);
+ // What it opened is what the next steps scroll.
+ for (core.panes, 0..) |slot, id| if (slot) |pane| if (pane.serial > newest) {
+ core.active = id;
+ core.needs_frame = true;
+ };
+ },
+ .end => in.close(),
+ }
+ }
+}
+
+/// The blink now, from the frame's time since input and how long ago it
+/// arrived; null where nothing blinks (off, idle, an unfocused window).
+fn blinkNow(g: *const Gui, chrome: ?*const pardes.Chrome) ?pardes.animation.Blink {
+ const frame = chrome orelse return null;
+ if (g.no_blink or frame.cursor_glide & 2 == 0 or frame.cursor_idle_ms == std.math.maxInt(u32)) return null;
+ if (c.SDL_GetWindowFlags(g.window) & c.SDL_WINDOW_INPUT_FOCUS == 0) return null;
+ const since = @as(u64, frame.cursor_idle_ms) * std.time.ns_per_ms + (monoNs() -| g.frame_arrival_ns);
+ // Relative to now: `next_ns` is how long until the next edge.
+ const b = pardes.animation.Blink.at(since, 0);
+ return .{ .alpha = b.alpha, .edge = b.edge, .next_ns = if (b.next_ns) |next| next -| since else null };
+}
+
+/// One refresh of the display the window is on, in ns; a frame of the
+/// core's where the display does not say.
+fn refreshNs(g: *const Gui) u64 {
+ const mode = c.SDL_GetCurrentDisplayMode(c.SDL_GetDisplayForWindow(g.window)) orelse return pardes.animation.frame_ns;
+ if (!(mode.*.refresh_rate > 1)) return pardes.animation.frame_ns;
+ return @intFromFloat(@as(f64, std.time.ns_per_s) / mode.*.refresh_rate);
}
fn finishWindowOpacity(core: *pardes.Pardes, applied: *u8, failure: ?[]const u8) void {
@@ -3876,25 +4464,26 @@ fn present(ctx: ?*anyopaque, surface: *const pardes.Surface) void {
const s = shellOf(ctx);
const core = s.core;
const g = s.gui orelse return;
+ frame_started_ns = monoNs();
const frame = @constCast(surface);
s.surface = frame;
- const scene_requested = core.settings.scene_effects.crt or
- core.settings.scene_effects.ripple or core.settings.scene_effects.glitch;
+ g.frame_arrival_ns = monoNs();
+ const scene_requested = g.post.ready();
if (!scene_requested) g.scene_failures = 0;
s.presented = renderFrame(
g,
s.gpa,
core,
frame,
- core.theme().bg,
- config.gui_topbar_pane_border_rgb orelse core.chromeTheme().border,
- core.chromeTheme().tag_bg,
- core.settings.scene_effects,
core.settings.debug,
) catch |err| blk: {
log.err("render: {t}", .{err});
break :blk false;
};
+ // A skipped swapchain image would otherwise hide this input's frame until
+ // the next event. A few retries only: a minimized window never gets one.
+ s.skipped_presents = if (s.presented) 0 else s.skipped_presents +| 1;
+ if (!s.presented and s.skipped_presents <= 3) core.present_skipped = true;
if (g.scene_target_failed) {
g.scene_failures +|= 1;
log.err("scene target unavailable (attempt {d}/3)", .{g.scene_failures});
@@ -3908,26 +4497,30 @@ fn present(ctx: ?*anyopaque, surface: *const pardes.Surface) void {
fn postPresent(ctx: ?*anyopaque) void {
const s = shellOf(ctx);
const g = s.gui orelse return;
+ // No image (a minimized window) shows no tracks; time still passes and
+ // the pump advances it all the same.
if (!s.presented) return;
const frame = s.surface orelse return;
refreshPresentedPointer(g, s.core);
- finishPresentedAnimationFrame(
- &s.animation_clock,
- s.core,
- frame.panelTracks(),
- c.SDL_GetTicksNS(),
- );
+ s.core.acknowledgePanelPresentation(frame.panelTracks());
+}
+
+fn guiNow(ctx: ?*anyopaque) u64 {
+ const s = shellOf(ctx);
+ return s.test_clock orelse s.paced_ns orelse c.SDL_GetTicksNS();
}
fn gridPollFrame(ctx: ?*anyopaque) void {
const s = shellOf(ctx);
s.reconcilePtys();
if (s.fs) |f| {
- if (f.tick(s.core).count != 0) s.saw_event = true;
+ if (f.tick().count != 0) s.saw_event = true;
}
pollCwds(s.core, s.ptys);
- if (s.core.animationActive()) {
- s.core.update(.tick);
+ // Grid time is virtual: each poll moves it straight to the core's
+ // next wake, a frame at a time while anything moves.
+ if (s.core.nextWake()) |due| {
+ s.core.advance(due);
s.saw_event = true;
}
}
@@ -3952,17 +4545,29 @@ fn gridPostPresent(ctx: ?*anyopaque) void {
fn spawnPane(ctx: ?*anyopaque, pane: u8, cwd: []const u8) void {
const s = shellOf(ctx);
s.reap();
+ // The new shell starts before a running one goes: one that cannot
+ // start leaves the running one be (pty/ctl's exec).
+ const running = s.ptys[pane] != null;
+ const child = host_io.forkShell(s.core, pane, s.prompt_rcs, s.core.shellBin(), cwd, s.core.screen_h, s.core.screen_w, s.fs) catch |err| {
+ if (running) return s.core.restartFailed(pane, err);
+ return s.core.shellFailed(pane, err);
+ };
s.closePty(pane);
- if (s.ptys[pane] != null) return s.core.reportError(pane, "shell", error.WorkersBusy);
+ if (s.ptys[pane] != null) {
+ _ = libc.close(child.file.handle);
+ host_io.retireShell(child.pid);
+ return s.core.reportError(pane, "shell", error.WorkersBusy);
+ }
s.gens[pane] +%= 1;
- const child = host_io.forkShell(s.core, pane, s.prompt_rcs, s.core.shellBin(), cwd, s.core.screen_h, s.core.screen_w, s.fs) catch |err| return s.core.reportError(pane, "shell", err);
- const pt: Pty = .{ .fd = child.file.handle, .pid = child.pid, .serial = s.core.panes[pane].?.serial };
+ const command = s.core.panes[pane].?.command != null;
+ const pt: Pty = .{ .fd = child.file.handle, .pid = child.pid, .serial = s.core.panes[pane].?.serial, .cmd = .{ .watched = command and host_io.watchExit(child.pid), .fd = child.file.handle } };
s.ptys[pane] = pt;
var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
if (host_io.shellCwd(pt.pid, &lbuf)) |wd| s.core.setCwd(pane, wd);
- if (s.threads_ok) spawnReader(s.gpa, &s.ptys[pane].?, pane, s.gens[pane], s.queue) catch |err| {
+ if (!s.threads_ok) return;
+ s.ptys[pane].?.reader = s.queue.startReader(.{ .handle = pt.fd, .flags = .{ .nonblocking = false } }, pane, s.gens[pane]) catch |err| {
s.closePty(pane);
- s.core.reportError(pane, "terminal reader", err);
+ return s.core.reportError(pane, "terminal reader", err);
};
}
@@ -3977,14 +4582,15 @@ fn ptyResize(ctx: ?*anyopaque, pane: u8, cols: u16, rows: u16) void {
const s = shellOf(ctx);
if (s.ptys[pane]) |pt| {
if (pt.fd < 0) return;
- const ws: posix.winsize = .{ .row = rows, .col = cols, .xpixel = 0, .ypixel = 0 };
+ const ws = host_io.ptyWinsize(s.core, cols, rows);
_ = posix.system.ioctl(pt.fd, TIOCSWINSZ, @intFromPtr(&ws));
}
}
fn ptySignal(ctx: ?*anyopaque, pane: u8, sig: pardes.PtySignal) void {
const s = shellOf(ctx);
- if (s.ptys[pane]) |pt| if (pt.fd >= 0) host_io.signalTty(pt.pid, pt.fd, sig);
+ // A command whose exit is recorded is reaped: its group may be another's.
+ if (s.ptys[pane]) |pt| if (pt.fd >= 0 and !pt.cmd.exited) host_io.signalTty(pt.pid, pt.fd, sig, pt.cmd.watched);
}
fn ttyTaken(ctx: ?*anyopaque, pane: u8) bool {
@@ -3994,27 +4600,27 @@ fn ttyTaken(ctx: ?*anyopaque, pane: u8) bool {
return host_io.ttyTaken(pt.pid, pt.fd);
}
+fn fgName(ctx: ?*anyopaque, pane: u8, buf: []u8) ?[]const u8 {
+ const s = shellOf(ctx);
+ const pt = s.ptys[pane] orelse return null;
+ if (pt.fd < 0) return null;
+ return host_io.foregroundName(pt.pid, pt.fd, buf);
+}
+
+fn killJob(ctx: ?*anyopaque, pane: u8) bool {
+ const s = shellOf(ctx);
+ const pt = s.ptys[pane] orelse return false;
+ if (pt.fd < 0) return false;
+ return host_io.killJob(pt.pid, pt.fd);
+}
+
fn writeFile(ctx: ?*anyopaque, pane: u8, path: []const u8, bytes: []const u8) void {
const s = shellOf(ctx);
- filesystem.write(s.core, path, bytes) catch |err|
- return s.core.saveFailed(pane, "save", err);
- if (s.core.panes[pane]) |pane_state| if (pane_state.file) |f| {
- if (std.mem.eql(u8, f.path, path))
- if (s.watches[pane]) |*w| if (w.serial == pane_state.serial) switch (w.generation) {
- .text => w.generation = .{ .text = std.hash.Wyhash.hash(0, bytes) },
- .pdf => {},
- };
- };
- var mbuf: [256]u8 = undefined;
- s.core.setMessage(pane, message.stamp(&mbuf, "saved", path));
+ host_io.writeFile(s.core, s.watches, pane, path, bytes);
}
fn writeDump(ctx: ?*anyopaque, bytes: []const u8) void {
- const s = shellOf(ctx);
- var pbuf: [1024:0]u8 = undefined;
- const path = pardes.dump.outPath(&pbuf) orelse return;
- filesystem.write(s.core, path, bytes) catch |err| return s.core.reportError(0, "dump", err);
- s.core.setLastDump(path);
+ host_io.writeDump(shellOf(ctx).core, bytes);
}
fn watchFile(ctx: ?*anyopaque, pane: u8, _: []const u8, on: bool, mode: pardes.WatchMode) void {
@@ -4038,18 +4644,11 @@ fn watchTheme(ctx: ?*anyopaque, generation: u32, on: bool) void {
fn dumpThemes(ctx: ?*anyopaque, pane: u8) void {
const s = shellOf(ctx);
- const config_dir = s.core.opts.config_dir orelse return;
- const out_dir = config.User.dumpThemes(s.io, s.gpa, config_dir, pardes.themes) catch |err| {
- s.core.reportError(pane, "dump themes", err);
- return;
- };
- defer s.gpa.free(out_dir);
- var mbuf: [256]u8 = undefined;
- s.core.setMessage(pane, message.stamp(&mbuf, "dumped themes", out_dir));
+ host_io.dumpThemes(s.core, s.io, s.gpa, pane);
}
fn putClipboard(gpa: std.mem.Allocator, text: []const u8) void {
- const z = gpa.dupeZ(u8, text) catch return;
+ const z = gpa.dupeSentinel(u8, text, 0) catch return;
defer gpa.free(z);
_ = c.SDL_SetClipboardText(z.ptr);
}
@@ -4082,12 +4681,10 @@ test "the headless grid host round-trips a yank back as a paste" {
var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
var gens: [pardes.MAX_PANES]u32 = @splat(0);
- var lsp_workers: LspWorkers = .{};
var queue: Queue = .{
+ .io = std.testing.io,
.gpa = gpa,
.lsp_allocator = gpa,
- .lsp_workers = &lsp_workers,
- .sdl_wake = false,
};
defer queue.deinit();
var pipe_tasks: PipeTasks = .{};
@@ -4115,7 +4712,7 @@ test "the headless grid host round-trips a yank back as a paste" {
core.update(.{ .key = .{ .cp = ' ' } });
core.update(.{ .key = .{ .cp = 'y' } });
while (core.nextEffect()) |e| core.perform(e);
- const yanked = core.yank orelse return error.MissingYank;
+ const yanked = core.registers.text(core.gpa, '+') orelse return error.MissingYank;
try std.testing.expect(yanked.len > 0);
const before = pane.file.?.content.len;
@@ -4127,6 +4724,39 @@ test "the headless grid host round-trips a yank back as a paste" {
try std.testing.expectEqual(before + yanked.len, pane.file.?.content.len);
}
+test "the clipboard pasted into a terminal reaches its pty as xterm pastes: bracketed when asked, no ESC[201~ smuggled through" {
+ if (comptime !pardes.panes.terminal.enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 60, .rows = 16, .tty_only = true });
+ defer core.deinit();
+ var shell: Shell = undefined;
+ shell.core = core;
+ var sent: std.ArrayList(u8) = .empty;
+ defer sent.deinit(gpa);
+ const take = struct {
+ fn f(core_: *pardes.Pardes, out: *std.ArrayList(u8)) ![]const u8 {
+ out.clearRetainingCapacity();
+ while (core_.nextEffect()) |effect| {
+ if (effect == .write and effect.write.pane == 0) try out.appendSlice(std.testing.allocator, effect.write.bytes.slice());
+ }
+ return out.items;
+ }
+ }.f;
+ _ = try take(core, &sent);
+ // The clipboard is SDL's own with no display to hold one.
+ _ = c.SDL_SetHint(c.SDL_HINT_VIDEO_DRIVER, "dummy");
+ defer _ = c.SDL_ResetHint(c.SDL_HINT_VIDEO_DRIVER);
+ if (!c.SDL_InitSubSystem(c.SDL_INIT_VIDEO)) return error.SkipZigTest;
+ defer c.SDL_QuitSubSystem(c.SDL_INIT_VIDEO);
+ putClipboard(gpa, "ls\x1b[201~; rm -rf ~\nx");
+ readClipboard(&shell);
+ try std.testing.expectEqualStrings("ls [201~; rm -rf ~\rx", try take(core, &sent));
+ core.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?2004h" } });
+ _ = try take(core, &sent);
+ readClipboard(&shell);
+ try std.testing.expectEqualStrings("\x1b[200~ls [201~; rm -rf ~\nx\x1b[201~", try take(core, &sent));
+}
+
fn openLink(ctx: ?*anyopaque, url: []const u8) void {
_ = ctx;
look.openLink(url); // desktop browser
@@ -4134,44 +4764,80 @@ fn openLink(ctx: ?*anyopaque, url: []const u8) void {
fn lsp(ctx: ?*anyopaque, req: host_io.Lsp.Request) void {
const s = shellOf(ctx);
- if (s.threads_ok) return spawnLsp(s.core, s.queue, req);
+ if (s.threads_ok) return s.queue.startLsp(s.core, req);
s.core.update(.{ .lsp_resp = .{ .id = req.id, .rows = null } });
s.core.reportError(req.pane, "lsp", error.WorkersUnavailable);
}
fn pipe(ctx: ?*anyopaque, id: u32) void {
const s = shellOf(ctx);
- if (s.threads_ok) return spawnPipe(s.core, s.io, s.gpa, s.queue, s.pipe_tasks, id);
+ if (s.threads_ok) return selection_pipe.start(s.io, s.gpa, s.core, s.pipe_tasks, id, s.queue, Queue.pushPipe);
s.core.update(.{ .pipe_resp = .{ .id = id, .success = false, .outputs = &.{} } });
s.core.reportError(s.core.active, "pipe", error.WorkersUnavailable);
}
+fn search(ctx: ?*anyopaque, gen: u32) void {
+ const s = shellOf(ctx);
+ if (s.threads_ok) return pardes.Stream.start(s.io, s.gpa, s.core, gen, s.queue, Queue.pushSearch);
+ pardes.Stream.runHere(s.core, gen);
+}
+
+/// Handover `seq`'s dump to its file, and a worker to carry it to another
+/// window (Handover.start). A new window is as big as this one, and where
+/// the pointer let go of it when the display lets a window say where it
+/// goes (X11; on Wayland the compositor places it).
+fn handOver(ctx: ?*anyopaque, seq: u32, bytes: []const u8) void {
+ const s = shellOf(ctx);
+ const Handover = pardes.Handover;
+ const path = Handover.dumpPath(s.gpa, seq) catch |err| return s.core.update(.{ .handed = .{ .seq = seq, .failure = @errorName(err) } });
+ const fd = libc.open(path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true, .CLOEXEC = true }, @as(libc.mode_t, 0o600));
+ const written = fd >= 0 and host_io.writeFd(fd, bytes);
+ if (fd >= 0) _ = libc.close(fd);
+ if (!written) {
+ _ = libc.unlink(path);
+ s.gpa.free(path);
+ return s.core.update(.{ .handed = .{ .seq = seq, .failure = "cannot write its dump" } });
+ }
+ const job = s.gpa.create(Handover.Job) catch {
+ _ = libc.unlink(path);
+ s.gpa.free(path);
+ return s.core.update(.{ .handed = .{ .seq = seq, .failure = "out of memory" } });
+ };
+ job.* = .{ .gpa = s.gpa, .seq = seq, .path = path, .post = Queue.pushHanded, .post_ctx = s.queue };
+ if (s.fs) |f| {
+ job.own_len = @min(f.path().len, job.own.len);
+ @memcpy(job.own[0..job.own_len], f.path()[0..job.own_len]);
+ }
+ if (s.gui) |g| {
+ var w: c_int = 0;
+ var h: c_int = 0;
+ _ = c.SDL_GetWindowSize(g.window, &w, &h);
+ var gx: f32 = 0;
+ var gy: f32 = 0;
+ _ = c.SDL_GetGlobalMouseState(&gx, &gy);
+ const placed = !std.mem.eql(u8, std.mem.span(c.SDL_GetCurrentVideoDriver()), "wayland");
+ const geometry = (if (placed)
+ std.fmt.bufPrint(&job.geometry, "{d}x{d}+{d}+{d}", .{ w, h, @as(i32, @intFromFloat(gx)) - 40, @as(i32, @intFromFloat(gy)) - 10 })
+ else
+ std.fmt.bufPrint(&job.geometry, "{d}x{d}", .{ w, h })) catch "";
+ job.geometry_len = geometry.len;
+ }
+ s.core.handover.start(s.io, job) catch |err| {
+ _ = libc.unlink(path);
+ s.gpa.free(path);
+ s.gpa.destroy(job);
+ return s.core.update(.{ .handed = .{ .seq = seq, .failure = @errorName(err) } });
+ };
+}
+
fn pollCwds(core: *pardes.Pardes, ptys: *[pardes.MAX_PANES]?Pty) void {
for (ptys, 0..) |slot, id| if (slot) |pt| {
if (pt.fd < 0) continue;
var lbuf: [pardes.memory.limits.host_path_cap + 1]u8 = undefined;
- if (host_io.shellCwd(pt.pid, &lbuf)) |cwd| core.setCwd(id, cwd);
+ if (host_io.ttyCwd(pt.pid, pt.fd, core.settings.shell.effective.get(), &lbuf)) |cwd| core.setCwd(id, cwd);
};
}
-fn shellClock() i64 {
- var ts: libc.timespec = undefined;
- if (libc.clock_gettime(.MONOTONIC, &ts) != 0) return 0;
- return @as(i64, ts.sec) * std.time.ms_per_s + @divTrunc(ts.nsec, std.time.ns_per_ms);
-}
-
-fn reapShell(pid: *libc.pid_t, kill_at: *i64, now: i64) void {
- if (pid.* <= 0) return;
- const result = libc.waitpid(pid.*, null, libc.W.NOHANG);
- if (result > 0 or (result < 0 and libc.errno(result) == .CHILD)) {
- pid.* = 0;
- kill_at.* = 0;
- } else if (kill_at.* != 0 and now >= kill_at.*) {
- _ = libc.kill(pid.*, libc.SIG.KILL);
- kill_at.* = 0;
- }
-}
-
fn accumulateWheelDelta(pending: f32, raw_y: f32) f32 {
if (!std.math.isFinite(raw_y)) return pending;
const next = pending - raw_y;
@@ -4248,14 +4914,573 @@ test "fractional scroll reversals preserve signed distance" {
try std.testing.expect(reverse.lag >= 0 and reverse.lag < 1);
}
+/// A mouse wheel's step as whole lines (down positive), or null for a
+/// touchpad's fraction, which follows the finger as it is.
+fn notchOf(raw_y: f32, integer_y: i32) ?i32 {
+ if (!std.math.isFinite(raw_y) or integer_y == 0 or raw_y != @round(raw_y)) return null;
+ return @intFromFloat(std.math.clamp(-raw_y, -64, 64));
+}
+
+test "a wheel's notch is whole lines, a touchpad's fraction is not" {
+ try std.testing.expectEqual(@as(?i32, 1), notchOf(-1, -1));
+ try std.testing.expectEqual(@as(?i32, -3), notchOf(3, 3));
+ try std.testing.expectEqual(@as(?i32, null), notchOf(-0.25, 0));
+ try std.testing.expectEqual(@as(?i32, null), notchOf(-1.5, -1));
+ try std.testing.expectEqual(@as(?i32, null), notchOf(std.math.nan(f32), 1));
+}
+
+test "a click over codex in a terminal reaches its pty with its modifiers; Shift swaps B1 to pardes and B2 to the program" {
+ if (comptime !pardes.panes.terminal.enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 60, .rows = 16, .tty_only = true });
+ defer core.deinit();
+ var frame: std.heap.ArenaAllocator = .init(gpa);
+ defer frame.deinit();
+ _ = try core.render(frame.allocator());
+ var in: Input = .{ .core = core };
+ var sent: std.ArrayList(u8) = .empty;
+ defer sent.deinit(gpa);
+ const take = struct {
+ fn f(core_: *pardes.Pardes, out: *std.ArrayList(u8)) ![]const u8 {
+ out.clearRetainingCapacity();
+ while (core_.nextEffect()) |effect| {
+ if (effect == .write and effect.write.pane == 0) try out.appendSlice(std.testing.allocator, effect.write.bytes.slice());
+ }
+ return out.items;
+ }
+ }.f;
+ _ = try take(core, &sent);
+ const pane = core.panes[0].?;
+ const r = core.rects[0];
+ const mc: MouseCell = .{ .col = r.x + config.GUTTER + 5, .row = core.bodyTop(pane, r) + 3 };
+ const next: MouseCell = .{ .col = mc.col + 1, .row = mc.row };
+ core.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?1049h\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h" } });
+ _ = try take(core, &sent);
+ in.post(.{ .mouse = pointerMouse(.none, .motion, mc, .{}) });
+ try std.testing.expectEqualStrings("\x1b[<35;6;4M", try take(core, &sent));
+ in.post(.{ .mouse = pointerMouse(.left, .press, mc, .{ .ctrl = true }) });
+ try std.testing.expectEqualStrings("\x1b[<16;6;4M", try take(core, &sent));
+ in.post(.{ .mouse = pointerMouse(.left, .drag, next, .{}) });
+ try std.testing.expectEqualStrings("\x1b[<32;7;4M", try take(core, &sent));
+ in.post(.{ .mouse = pointerMouse(.left, .release, next, .{}) });
+ try std.testing.expectEqualStrings("\x1b[<0;7;4m", try take(core, &sent));
+ // Shift-B1 is pardes's select; B2 is pardes's execute and Shift-B2
+ // the program's, reported without the Shift.
+ in.post(.{ .mouse = pointerMouse(.left, .press, mc, .{ .shift = true }) });
+ in.post(.{ .mouse = pointerMouse(.left, .release, mc, .{ .shift = true }) });
+ try std.testing.expectEqualStrings("", try take(core, &sent));
+ in.post(.{ .mouse = pointerMouse(.middle, .press, mc, .{}) });
+ in.post(.{ .mouse = pointerMouse(.middle, .release, mc, .{}) });
+ try std.testing.expectEqualStrings("", try take(core, &sent));
+ in.post(.{ .mouse = pointerMouse(.middle, .press, mc, .{ .shift = true }) });
+ in.post(.{ .mouse = pointerMouse(.middle, .release, mc, .{ .shift = true }) });
+ try std.testing.expectEqualStrings("\x1b[<1;6;4M\x1b[<1;6;4m", try take(core, &sent));
+}
+
+test "a wheel over codex in a terminal reaches its pty as the mouse reports it asked for" {
+ if (comptime !pardes.panes.terminal.enabled) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 60, .rows = 16, .tty_only = true });
+ defer core.deinit();
+ var frame: std.heap.ArenaAllocator = .init(gpa);
+ defer frame.deinit();
+ _ = try core.render(frame.allocator());
+ var g: Gui = undefined;
+ g.scroll_pane = null;
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ g.scroll_notch = 0;
+ g.program_wheel = 0;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.cell_h = 20;
+ var in: Input = .{ .core = core };
+ var sent: std.ArrayList(u8) = .empty;
+ defer sent.deinit(gpa);
+ const Sent = struct {
+ fn take(core_: *pardes.Pardes, out: *std.ArrayList(u8)) ![]const u8 {
+ out.clearRetainingCapacity();
+ while (core_.nextEffect()) |effect| {
+ if (effect == .write and effect.write.pane == 0) try out.appendSlice(std.testing.allocator, effect.write.bytes.slice());
+ }
+ return out.items;
+ }
+ };
+ _ = try Sent.take(core, &sent);
+ const pane = core.panes[0].?;
+ const r = core.rects[0];
+ const mc: MouseCell = .{ .col = r.x + config.GUTTER + 5, .row = core.bodyTop(pane, r) + 3 };
+ // What codex 0.159's chat sets on start.
+ core.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?2004h\x1b[>7u\x1b[?1004h\x1b[?1049h\x1b[?1007l\x1b[?1000h\x1b[?1002h\x1b[?1003h\x1b[?1006h" } });
+ _ = try Sent.take(core, &sent);
+ // A notch up, then a fast turn of three down: each its report, none
+ // left behind for a glide.
+ wheelAt(&g, &in, .{ .y = 1, .integer_y = 1 }, mc);
+ try std.testing.expectEqualStrings("\x1b[<64;6;4M", try Sent.take(core, &sent));
+ wheelAt(&g, &in, .{ .y = -3, .integer_y = -3 }, mc);
+ try std.testing.expectEqualStrings(std.mem.asBytes(&@as([3][10]u8, @splat("\x1b[<65;6;4M".*))), try Sent.take(core, &sent));
+ try std.testing.expectEqual(@as(i32, 0), g.scroll_notch);
+ try std.testing.expect(g.scroll_pane == null);
+ // A touchpad's fractions add up to a turn.
+ wheelAt(&g, &in, .{ .y = 0.5 }, mc);
+ try std.testing.expectEqualStrings("", try Sent.take(core, &sent));
+ wheelAt(&g, &in, .{ .y = 0.5 }, mc);
+ try std.testing.expectEqualStrings("\x1b[<64;6;4M", try Sent.take(core, &sent));
+ // Alt is meta, 8; Shift keeps the turn pardes's own, a glide.
+ wheelAt(&g, &in, .{ .y = 1, .integer_y = 1, .mods = .{ .alt = true } }, mc);
+ try std.testing.expectEqualStrings("\x1b[<72;6;4M", try Sent.take(core, &sent));
+ wheelAt(&g, &in, .{ .y = 1, .integer_y = 1, .mods = .{ .shift = true } }, mc);
+ try std.testing.expectEqualStrings("", try Sent.take(core, &sent));
+ try std.testing.expectEqual(@as(i32, -1), g.scroll_notch);
+ stepGlide(&g, core, gpa);
+ try std.testing.expectEqualStrings("", try Sent.take(core, &sent));
+ resetScroll(&g);
+ // Its sign-in screen: mouse off, alternate scroll on, so arrow keys.
+ core.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?1006l\x1b[?1003l\x1b[?1002l\x1b[?1000l\x1b[?1007h" } });
+ _ = try Sent.take(core, &sent);
+ wheelAt(&g, &in, .{ .y = -1, .integer_y = -1 }, mc);
+ try std.testing.expectEqualStrings("\x1b[B", try Sent.take(core, &sent));
+ // Back on the main screen a shell's wheel is ours: a notch to glide,
+ // nothing to the pty.
+ core.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[?1049l" } });
+ _ = try Sent.take(core, &sent);
+ wheelAt(&g, &in, .{ .y = 1, .integer_y = 1 }, mc);
+ try std.testing.expectEqualStrings("", try Sent.take(core, &sent));
+ try std.testing.expectEqual(@as(i32, -1), g.scroll_notch);
+}
+
+const Glide = pardes.glide.Glide;
+
+/// Feeds a wheel's notches to the core, then steps the glide (Glide.step)
+/// and asks for frames while it moves.
+fn stepGlide(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
+ const glide = &g.glide;
+ // The glide runs on the core's continuous path: frames every loop, and
+ // a virtual clock carried on.
+ defer core.shell_continuous = glide.moving() or g.sel_glow.fading or g.hover_glow.fading;
+ const notch = g.scroll_notch;
+ g.scroll_notch = 0;
+ var wheeled: ?usize = null;
+ if (notch != 0) wheel: {
+ const id = g.scroll_pane orelse break :wheel;
+ const pane = core.panes[id] orelse {
+ resetScroll(g);
+ break :wheel;
+ };
+ const r = core.rects[id];
+ if (r.h <= pane.tag_rows or r.w <= config.GUTTER) {
+ resetScroll(g);
+ break :wheel;
+ }
+ var left = notch;
+ while (left != 0) {
+ const down = left > 0;
+ left += if (down) -1 else 1;
+ const was = pane.scroll();
+ // Shift: pardes's own scroll, never a program's wheel.
+ core.update(.{ .mouse = .{ .button = if (down) .wheel_down else .wheel_up, .kind = .press, .col = g.scroll_col, .row = g.scroll_row, .shift = true } });
+ if (pane.scroll() == was) break;
+ wheeled = id;
+ }
+ if (wheeled != null) core.needs_frame = true;
+ }
+ // Not a view a touchpad is moving by the pixel.
+ const direct: ?usize = if (g.scroll_lag != 0 or g.scroll_delta != 0) g.scroll_pane else null;
+ glide.step(core, gpa, wheeled, direct);
+}
+
+/// The glide's picture: the pane's body rows moved by the offset, and in
+/// the gap it opens the rows that left, as `emitScrollRows` draws a
+/// touchpad's fraction.
+fn emitGlideRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground, held: u16) u32 {
+ const glide = &g.glide;
+ for (surface.panelTracks()) |track|
+ if (track.active() and track.pane == glide.pane) return 0;
+ const r = glide.rect;
+ const bh = glide.body_h;
+ const bw = glide.bw();
+ const x0 = r.x + config.GUTTER;
+ const y0 = glide.body_y;
+ if (bw == 0 or bh == 0 or x0 + bw > surface.cols or y0 + bh > surface.rows) return 0;
+ // The scissor the shifted rows are drawn in is the scroll's.
+ g.scroll_rect = r;
+ g.scroll_body_y = y0;
+ g.scroll_body_h = bh;
+ var shifted = layout;
+ shifted.y_off -= glide.follow.offset * layout.h;
+ const kept = holdContext(g, surface, glide.pane, held, bh, layout);
+ shifted.y_off += kept.lift;
+ var n: u32 = 0;
+ // Only the rows the scissor shows: lagging a body or more, every body
+ // row is past the edge, and drawing them all was twice the frame's
+ // instances for the length of a long glide.
+ const lag: u16 = @intFromFloat(@min(@floor(@abs(glide.follow.offset)), @as(f32, @floatFromInt(bh))));
+ var row = y0 + kept.rows + if (glide.follow.offset > 0) lag else 0;
+ const row_end = y0 + bh - if (glide.follow.offset < 0) lag else 0;
+ while (row < row_end) : (row += 1) {
+ const line = surface.cells[@as(usize, row) * surface.cols ..][0..surface.cols];
+ const row_cursor: ?usize = if (surface.cursor) |cu| if (cu.y == row) cu.x else null else null;
+ var col = x0;
+ while (col < x0 + bw) : (col += 1) {
+ // No caret among the moving rows: it is drawn from its own
+ // springs (the quad), never carried by the text's glide.
+ emitInstance(g, instances, base + n, col, row, shifted, win_w, win_h, null, cellFontRole(surface.at(col, row)), line, col, row_cursor, false, false, page);
+ n += 1;
+ }
+ }
+ // The gap: rows past the top while the picture lags a move down, past
+ // the bottom for one up; as many as it opens.
+ const gap: u16 = @intFromFloat(@min(@ceil(@abs(glide.follow.offset)), @as(f32, @floatFromInt(@as(u32, bh) * Glide.reach))));
+ const nkept = if (glide.follow.offset < 0) glide.nabove else glide.nbelow;
+ const rows = if (glide.follow.offset < 0) glide.above else glide.below;
+ for (0..@min(gap, nkept)) |i| {
+ const cells = rows[i * bw ..][0..bw];
+ // Row -1 - i above the body, or bh + i below it, in grid rows.
+ const at_row: i32 = if (glide.follow.offset < 0) @as(i32, y0) - 1 - @as(i32, @intCast(i)) else @as(i32, y0) + bh + @as(i32, @intCast(i));
+ var at = shifted;
+ // emitInstance takes an unsigned row: move the layout instead.
+ at.y_off += @as(f32, @floatFromInt(at_row - @as(i32, y0))) * layout.h;
+ for (0..bw) |c_i| {
+ emitInstance(g, instances, base + n, x0 + @as(u16, @intCast(c_i)), y0, at, win_w, win_h, null, cellFontRole(&cells[c_i]), cells, c_i, null, false, false, page);
+ n += 1;
+ }
+ }
+ return n;
+}
+
+test "a notch scrolls the core at once and the picture glides after it, a wrapped line's rows at a time" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ // Lines of two rows each at this width, numbered so no two rows match.
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ for (0..60) |i| {
+ try text.print(gpa, "{d:0>4} ", .{i});
+ try text.appendNTimes(gpa, 'a' + @as(u8, @intCast(i % 26)), 100);
+ try text.append(gpa, '\n');
+ }
+ _ = try core.setTestFile(text.items);
+ core.settings.motion = .smooth;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ const ms = std.time.ns_per_ms;
+ var now: u64 = std.time.ns_per_s;
+ core.advance(now);
+ var s = try core.render(arena.allocator());
+ var g: Gui = undefined;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ const r = core.rects[core.active];
+ g.scroll_pane = core.active;
+ g.scroll_col = r.x + 10;
+ g.scroll_row = r.y + r.h - 2;
+ const body_y = core.bodyTop(core.panes[core.active].?, r);
+ const row_before = try gpa.dupe(pardes.Cell, s.cells[@as(usize, body_y + 1) * s.cols + r.x + config.GUTTER ..][0 .. r.w - config.GUTTER]);
+ defer gpa.free(row_before);
+ // The loop has seen the view once (stepGlide finds a view that moved).
+ stepGlide(&g, core, gpa);
+ // One notch down: the core is a line on at once.
+ g.scroll_notch = 1;
+ const scrolled = core.panes[core.active].?.scroll();
+ stepGlide(&g, core, gpa);
+ try std.testing.expectEqual(scrolled + 1, core.panes[core.active].?.scroll());
+ try std.testing.expect(g.glide.pending);
+ // On the core's continuous path while it moves: frames every loop.
+ try std.testing.expect(core.shell_continuous and core.continuous());
+ _ = arena.reset(.retain_capacity);
+ s = try core.render(arena.allocator());
+ g.glide.measure(gpa, s);
+ // Its two rows: the picture two rows behind, the rows that left kept,
+ // nearest first.
+ try std.testing.expectApproxEqAbs(@as(f32, -2), g.glide.follow.offset, 1e-4);
+ try std.testing.expectEqual(@as(u16, 2), g.glide.nabove);
+ try std.testing.expect(pardes.glide.sameRow(g.glide.above[0 .. r.w - config.GUTTER], row_before));
+ // Frame by frame it comes back, never past, and settles.
+ var frames: usize = 0;
+ while (g.glide.moving()) : (frames += 1) {
+ now += 7 * ms;
+ core.advance(now);
+ stepGlide(&g, core, gpa);
+ try std.testing.expect(g.glide.follow.offset <= 1e-4);
+ if (frames > 200) return error.NeverSettled;
+ }
+ try std.testing.expect(frames > 5);
+ try std.testing.expectEqual(@as(f32, 0), g.glide.follow.offset);
+ try std.testing.expect(!core.shell_continuous);
+ // Motion off: a notch lands at once.
+ core.settings.motion = .off;
+ g.scroll_notch = 1;
+ stepGlide(&g, core, gpa);
+ try std.testing.expect(!g.glide.pending and !g.glide.moving());
+}
+
+test "a wheel's caret rides with its line, the text's own glide, never a spring of its own" {
+ if (!pardes.builtins.capabilities.lift) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ for (0..200) |i| try text.print(gpa, "line {d}\n", .{i});
+ _ = try core.setTestFile(text.items);
+ core.settings.motion = .smooth;
+ core.settings.cursor_blink = false;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ var now: u64 = std.time.ns_per_s;
+ core.advance(now);
+ for ("10G") |ch| core.update(.{ .key = .{ .cp = ch, .text = &.{ch} } });
+ _ = try core.render(arena.allocator());
+ now += std.time.ns_per_s;
+ core.advance(now);
+ _ = arena.reset(.retain_capacity);
+ var s = try core.render(arena.allocator());
+ var g: Gui = undefined;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ const r = core.rects[core.active];
+ g.scroll_pane = core.active;
+ g.scroll_col = r.x + 10;
+ g.scroll_row = r.y + r.h - 2;
+ stepGlide(&g, core, gpa);
+ const before: f32 = @floatFromInt(s.cursor.?.y);
+ g.scroll_notch = 1;
+ stepGlide(&g, core, gpa);
+ var frames: usize = 0;
+ while (true) : (frames += 1) {
+ now += 7 * std.time.ns_per_ms;
+ core.advance(now);
+ _ = arena.reset(.retain_capacity);
+ s = try core.render(arena.allocator());
+ if (g.glide.pending) g.glide.measure(gpa, s);
+ if (frames == 0) {
+ try std.testing.expect(g.glide.caret_rides);
+ // Where its line is drawn: on the row it was on, the cell a row up.
+ try std.testing.expectApproxEqAbs(before, caretRow(&g, s).?, 1e-3);
+ }
+ // Always exactly with its line, the cell less the text's offset.
+ try std.testing.expectApproxEqAbs(@as(f32, @floatFromInt(s.cursor.?.y)) - g.glide.follow.offset, caretRow(&g, s).?, 1e-3);
+ if (!g.glide.moving()) break;
+ stepGlide(&g, core, gpa);
+ if (frames > 200) return error.NeverSettled;
+ }
+ try std.testing.expectEqual(@as(f32, @floatFromInt(s.cursor.?.y)), caretRow(&g, s).?);
+}
+
+/// The scripted scroll sequence of the glide tests: a frame a 60 Hz
+/// refresh, as the paced loop draws them (waitInput, then stepGlide, the
+/// core's render and the frame's measure), an input on the frames `script`
+/// names; each frame's picture offset and the core's first line.
+const GlideRun = struct {
+ const Step = struct { frame: usize, key: pardes.Key };
+ offsets: [600]f32 = undefined,
+ lines: [600]i64 = undefined,
+ carets: [600]f32 = undefined,
+ cells: [600]f32 = undefined,
+ frames: usize = 0,
+
+ fn play(seq: *GlideRun, g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator, arena: *std.heap.ArenaAllocator, script: []const Step, frames: usize) !void {
+ var now: u64 = core.now_ns;
+ var next: usize = 0;
+ for (0..frames) |frame| {
+ while (next < script.len and script[next].frame == frame) : (next += 1) core.update(.{ .key = script[next].key });
+ now += std.time.ns_per_s / 60;
+ core.advance(now);
+ stepGlide(g, core, gpa);
+ _ = arena.reset(.retain_capacity);
+ const s = try core.render(arena.allocator());
+ if (g.glide.pending) g.glide.measure(gpa, s);
+ if (g.glide.moving()) g.glide.advance(g.glide.now_ns, g.glide.motion);
+ seq.offsets[frame] = g.glide.follow.offset;
+ seq.lines[frame] = @intCast(core.panes[core.active].?.file.?.scroll);
+ seq.carets[frame] = caretRow(g, s) orelse -1;
+ seq.cells[frame] = if (s.cursor) |cu| @floatFromInt(cu.y) else -1;
+ }
+ seq.frames = frames;
+ }
+
+ /// The caret's invariants over the run: while its cell stays and it is
+ /// on it, it does not move a pixel; it only ever closes on its cell (a
+ /// twentieth of a row of play for a jump's bow); it lands within half a
+ /// second of its last change.
+ fn checkCaret(seq: *const GlideRun) !void {
+ var changed: usize = 0;
+ for (1..seq.frames) |k| {
+ if (seq.cells[k] < 0 or seq.cells[k - 1] < 0) continue;
+ if (seq.cells[k] != seq.cells[k - 1]) changed = k;
+ if (seq.cells[k] == seq.cells[k - 1] and seq.carets[k - 1] == seq.cells[k - 1]) try std.testing.expectEqual(seq.carets[k - 1], seq.carets[k]);
+ try std.testing.expect(@abs(seq.carets[k] - seq.cells[k]) <= @abs(seq.carets[k - 1] - seq.cells[k]) + 0.05);
+ if (k - changed == 30) try std.testing.expectEqual(seq.cells[k], seq.carets[k]);
+ }
+ }
+
+ /// Frames from `from` until the picture is still: the scroll's glide.
+ fn settle(seq: *const GlideRun, from: usize) usize {
+ var k = from;
+ while (k < seq.frames and seq.offsets[k] != 0) k += 1;
+ return k - from;
+ }
+};
+
+test "every scroll glides on one law: a half page, a page, the far jumps, a run of them retargeting, and Motion off lands at once" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 100, .rows = 40 });
+ defer core.deinit();
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ // Numbered lines no two alike, short enough never to wrap.
+ for (0..3000) |i| try text.print(gpa, "{d:0>5} line {d} of the long file\n", .{ i, i * 7 % 13 });
+ _ = try core.setTestFile(text.items);
+ core.settings.motion = .smooth;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ core.advance(std.time.ns_per_s);
+ _ = try core.render(arena.allocator());
+ var g: Gui = undefined;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.scroll_notch = 0;
+ g.scroll_pane = null;
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ g.sel_glow = .{};
+ g.hover_glow = .{};
+ const body_h: f32 = @floatFromInt(core.rects[core.active].h - core.panes[core.active].?.tag_rows);
+ const ctrl = struct {
+ fn key(cp: u21) pardes.Key {
+ return .{ .cp = cp, .ctrl = true };
+ }
+ };
+ const script = [_]GlideRun.Step{
+ .{ .frame = 2, .key = ctrl.key('d') },
+ .{ .frame = 40, .key = ctrl.key('f') },
+ .{ .frame = 80, .key = .{ .cp = 'g', .text = "g" } },
+ .{ .frame = 80, .key = .{ .cp = 'e', .text = "e" } },
+ .{ .frame = 120, .key = .{ .cp = 'g', .text = "g" } },
+ .{ .frame = 120, .key = .{ .cp = 'g', .text = "g" } },
+ // Faster than they settle: each adds to the glide under way.
+ .{ .frame = 160, .key = ctrl.key('d') },
+ .{ .frame = 165, .key = ctrl.key('d') },
+ .{ .frame = 170, .key = ctrl.key('d') },
+ .{ .frame = 175, .key = ctrl.key('d') },
+ };
+ var seq: GlideRun = .{};
+ try seq.play(&g, core, gpa, &arena, &script, 240);
+ try seq.checkCaret();
+ // Every one moves the picture on the frame it is drawn in, and the
+ // picture lags by what the core moved (a far jump, by one body).
+ var longest: usize = 0;
+ var shortest: usize = std.math.maxInt(usize);
+ for ([_]usize{ 2, 40, 80, 120 }) |at| {
+ const moved: f32 = @floatFromInt(@abs(seq.lines[at] - seq.lines[at - 1]));
+ try std.testing.expect(moved >= 1);
+ const lag = @abs(seq.offsets[at]);
+ try std.testing.expect(lag > 0.5 * @min(moved, body_h));
+ try std.testing.expect(lag <= @min(moved, body_h) + 1e-3);
+ // Settles on the same law whatever the distance: a few frames for
+ // a half page, not many more for a jump of 3000 lines.
+ const frames = seq.settle(at);
+ longest = @max(longest, frames);
+ shortest = @min(shortest, frames);
+ try std.testing.expect(frames >= 8 and frames <= 24);
+ }
+ try std.testing.expect(longest - shortest <= 5);
+ // Readable: never more than a quarter of a body a frame once it moves.
+ for (1..seq.frames) |k| {
+ if (seq.lines[k] != seq.lines[k - 1]) continue;
+ try std.testing.expect(@abs(seq.offsets[k] - seq.offsets[k - 1]) <= body_h / 4 + 1e-3);
+ }
+ // The seq of half pages: one glide, never at rest between them, and
+ // done as soon after the last as one half page alone takes.
+ for (160..180) |k| try std.testing.expect(seq.offsets[k] != 0);
+ try std.testing.expect(seq.settle(175) <= seq.settle(2) + 4);
+ // Motion off: the same scroll lands at once.
+ core.settings.motion = .off;
+ var off: GlideRun = .{};
+ try off.play(&g, core, gpa, &arena, &.{.{ .frame = 1, .key = ctrl.key('u') }}, 10);
+ try std.testing.expect(off.lines[1] != off.lines[0]);
+ for (off.offsets[0..off.frames]) |offset| try std.testing.expectEqual(@as(f32, 0), offset);
+}
+
+test "a held key moves the view at the stream's own rate, never a bounce a line, and settles once it stops" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 100, .rows = 40 });
+ defer core.deinit();
+ var text: std.ArrayList(u8) = .empty;
+ defer text.deinit(gpa);
+ for (0..3000) |i| try text.print(gpa, "{d:0>5} line {d} of the long file\n", .{ i, i * 7 % 13 });
+ _ = try core.setTestFile(text.items);
+ core.settings.motion = .smooth;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ core.advance(std.time.ns_per_s);
+ _ = try core.render(arena.allocator());
+ var g: Gui = undefined;
+ g.glide = .{};
+ defer g.glide.deinit(gpa);
+ g.scroll_notch = 0;
+ g.scroll_pane = null;
+ g.scroll_delta = 0;
+ g.scroll_lag = 0;
+ g.scroll_edge_len = 0;
+ g.sel_glow = .{};
+ g.hover_glow = .{};
+ // j held from the top: a repeat every second frame, the view following
+ // a line a repeat once the caret is at its last rows.
+ var script: [48]GlideRun.Step = undefined;
+ for (&script, 0..) |*step, i| step.* = .{ .frame = 20 + 2 * i, .key = .{ .cp = 'j', .text = "j" } };
+ var seq: GlideRun = .{};
+ try seq.play(&g, core, gpa, &arena, &script, 200);
+ // Inside the stream the picture moves every frame by about the same
+ // step: an input's rows over its spacing, not a spring's ease to each.
+ var least: f32 = std.math.inf(f32);
+ var most: f32 = 0;
+ for (90..110) |k| {
+ const step = (@as(f32, @floatFromInt(seq.lines[k])) + seq.offsets[k]) - (@as(f32, @floatFromInt(seq.lines[k - 1])) + seq.offsets[k - 1]);
+ least = @min(least, step);
+ most = @max(most, step);
+ }
+ try std.testing.expect(seq.lines[89] > 0 and least > 0.4 and most < 0.6);
+ // The caret stays on its row, the text moving under it: not a pixel's
+ // wobble (the glide's fractional lag never reaches it).
+ for (90..110) |k| try std.testing.expectEqual(seq.carets[89], seq.carets[k]);
+ // It comes to rest once the keys stop, never past its mark.
+ for (110..200) |k| try std.testing.expect(seq.offsets[k] <= 0);
+ try std.testing.expectEqual(@as(f32, 0), seq.offsets[199]);
+ // Ctrl-d held, then PageDown held: the caret keeps its row the whole
+ // way, the pages moving under it.
+ var pages: [40]GlideRun.Step = undefined;
+ for (&pages, 0..) |*step, i| step.* = .{ .frame = 10 + 2 * i, .key = if (i < 20) .{ .cp = 'd', .ctrl = true } else .{ .cp = pardes.Key.page_down } };
+ var held: GlideRun = .{};
+ try held.play(&g, core, gpa, &arena, &pages, 100);
+ try held.checkCaret();
+ try seq.checkCaret();
+ // (The first of each may move it, one ease: from the last row to where
+ // a half page keeps it, and from there to a page's.)
+ for (30..50) |k| try std.testing.expectEqual(held.carets[30], held.carets[k]);
+ for (70..90) |k| try std.testing.expectEqual(held.carets[70], held.carets[k]);
+}
+
fn resetScroll(g: *Gui) void {
g.scroll_pane = null;
g.scroll_delta = 0;
g.scroll_lag = 0;
g.scroll_edge_len = 0;
+ g.scroll_notch = 0;
+ g.glide.stop();
}
fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
+ stepGlide(g, core, gpa);
const id = g.scroll_pane orelse return;
const pane = core.panes[id] orelse {
resetScroll(g);
@@ -4264,27 +5489,30 @@ fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
const queued_delta = g.scroll_delta;
g.scroll_delta = 0;
if (queued_delta == 0) {
- if (g.scroll_lag == 0) resetScroll(g);
+ if (g.scroll_lag == 0 and g.scroll_notch == 0 and !g.glide.moving()) resetScroll(g);
return;
}
const r = core.rects[id];
- if (r.h <= pardes.BOX_H) {
+ if (r.h <= pane.tag_rows) {
resetScroll(g);
return;
}
- const delta = boundScrollDelta(g.scroll_lag, queued_delta, r.h - pardes.BOX_H);
+ const delta = boundScrollDelta(g.scroll_lag, queued_delta, r.h - pane.tag_rows);
const st = applyScrollDelta(g.scroll_lag, delta);
var left = st.rows;
while (left != 0) {
const down = left > 0;
left += if (down) -1 else 1;
const was = pane.scroll();
- core.update(.{ .mouse = .{
- .button = if (down) .wheel_down else .wheel_up,
- .kind = .press,
- .col = g.scroll_col,
- .row = g.scroll_row,
- } });
+ core.update(.{
+ .mouse = .{
+ .button = if (down) .wheel_down else .wheel_up,
+ .kind = .press,
+ .col = g.scroll_col,
+ .row = g.scroll_row,
+ .shift = true, // pardes's own scroll, never a program's wheel
+ },
+ });
if (pane.scroll() == was) {
resetScroll(g);
return;
@@ -4292,14 +5520,15 @@ fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
}
g.scroll_lag = st.lag;
g.scroll_rect = r;
- const body_y = if (core.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
+ const body_y = core.bodyTop(pane, r);
g.scroll_body_y = body_y;
+ g.scroll_body_h = r.h -| pane.tag_rows;
if (st.rows != 0) {
const s = &core.surface;
g.scroll_edge_len = 0;
- if (r.w > config.GUTTER and r.h > pardes.BOX_H and r.x + r.w <= s.cols) {
+ if (r.w > config.GUTTER and r.h > pane.tag_rows and r.x + r.w <= s.cols) {
const bw = r.w - config.GUTTER;
- const bh = r.h - pardes.BOX_H;
+ const bh = g.scroll_body_h;
const k: u16 = @intCast(@min(@abs(st.rows), @as(i32, bh)));
const srow = body_y + (if (st.rows > 0) k - 1 else bh - k);
if (srow < s.rows) {
@@ -4317,29 +5546,35 @@ fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
if (g.scroll_lag == 0) resetScroll(g);
}
-fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground) u32 {
+fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground, held: u16) u32 {
+ g.scroll_held_px = 0;
+ if (g.glide.follow.offset != 0) return emitGlideRows(g, instances, base, surface, layout, win_w, win_h, page, held);
const scroll_pane = g.scroll_pane orelse return 0;
if (g.scroll_lag == 0) return 0;
for (surface.panelTracks()) |track|
if (track.active() and track.pane == scroll_pane) return 0;
const r = g.scroll_rect;
- if (r.w <= config.GUTTER or r.h <= pardes.BOX_H) return 0;
+ const bh = g.scroll_body_h;
+ if (r.w <= config.GUTTER or bh == 0) return 0;
const x0 = r.x + config.GUTTER;
const y0 = g.scroll_body_y;
const bw = r.w - config.GUTTER;
- const bh = r.h - pardes.BOX_H;
if (x0 + bw > surface.cols or y0 + bh > surface.rows) return 0; // resized under us
var shifted = layout;
shifted.y_off -= g.scroll_lag * layout.h;
+ const kept = holdContext(g, surface, scroll_pane, held, bh, layout);
+ shifted.y_off += kept.lift;
const cursor_idx: u32 = if (surface.cursor) |cu| @as(u32, cu.y) * surface.cols + cu.x else std.math.maxInt(u32);
const cursor_bar = if (surface.cursor) |cu| cu.bar else false;
var n: u32 = 0;
- var row = y0;
+ var row = y0 + kept.rows;
while (row < y0 + bh) : (row += 1) {
+ const line = surface.cells[@as(usize, row) * surface.cols ..][0..surface.cols];
+ const row_cursor: ?usize = if (surface.cursor) |cu| if (cu.y == row) cu.x else null else null;
var col = x0;
while (col < x0 + bw) : (col += 1) {
const sidx: u32 = @as(u32, row) * surface.cols + col;
- emitInstance(g, instances, base + n, col, row, shifted, win_w, win_h, null, cellFontRole(surface.at(col, row)), surface.at(col, row), false, sidx == cursor_idx and !cursor_bar, page);
+ emitInstance(g, instances, base + n, col, row, shifted, win_w, win_h, null, cellFontRole(surface.at(col, row)), line, col, row_cursor, false, sidx == cursor_idx and !cursor_bar, page);
n += 1;
}
}
@@ -4347,19 +5582,59 @@ fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pard
const erow: u16 = if (g.scroll_lag > 0) y0 + bh else y0 - 1;
var i: u16 = 0;
while (i < bw) : (i += 1) {
- emitInstance(g, instances, base + n, x0 + i, erow, shifted, win_w, win_h, null, cellFontRole(&g.scroll_edge[i]), &g.scroll_edge[i], false, false, page);
+ emitInstance(g, instances, base + n, x0 + i, erow, shifted, win_w, win_h, null, cellFontRole(&g.scroll_edge[i]), g.scroll_edge[0..bw], i, null, false, false, page);
n += 1;
}
}
return n;
}
+/// A scrolling body's tree-sitter context rows hold still: the shifted
+/// rows start under them and are clipped below their band, and where a
+/// body layer stacks them at the tagline's height (TreeContextTagStyle)
+/// the rows under them are drawn up to meet them, where the layer has them.
+fn holdContext(g: *Gui, surface: *const pardes.Surface, id: usize, held: u16, bh: u16, layout: CellLayout) struct { rows: u16, lift: f32 } {
+ const rows = @min(held, bh);
+ const layered = id < surface.body_layers.len and surface.body_layers[id].rows != 0 and surface.body_layers[id].context_rows != 0;
+ const row_px = if (layered) std.math.clamp(@as(f32, @floatFromInt(g.tagline_height)), 1, @max(1, layout.h)) else layout.h;
+ g.scroll_held_px = @as(f32, @floatFromInt(rows)) * row_px;
+ return .{ .rows = rows, .lift = @as(f32, @floatFromInt(rows)) * (row_px - layout.h) };
+}
+
+test "a scroll's shifted rows start under the context rows, and its scissor below their band" {
+ var surface: pardes.Surface = .{};
+ var g: Gui = undefined;
+ g.tagline_height = 12;
+ g.scroll_rect = .{ .x = 0, .y = 0, .w = 40, .h = 20 };
+ g.scroll_body_y = 1;
+ g.scroll_body_h = 19;
+ const layout: CellLayout = .{ .w = 10, .h = 20, .x_off = 0, .y_off = 0 };
+ // On the grid, three body-high rows are held, and nothing moves up.
+ const grid = holdContext(&g, &surface, 0, 3, 19, layout);
+ try std.testing.expectEqual(@as(u16, 3), grid.rows);
+ try std.testing.expectEqual(@as(f32, 0), grid.lift);
+ const clip = scrollScissor(&g, layout, 400, 400);
+ try std.testing.expectEqual(@as(c_int, 20 + 3 * 20), clip.y);
+ try std.testing.expectEqual(@as(c_int, 16 * 20), clip.h);
+ // In a body layer they are tagline-high: the rows under them move up
+ // by what each is shorter, to where the layer draws them.
+ surface.body_layers[0].rows = 30;
+ surface.body_layers[0].context_rows = 3;
+ const layered = holdContext(&g, &surface, 0, 3, 19, layout);
+ try std.testing.expectEqual(@as(f32, 3 * (12 - 20)), layered.lift);
+ try std.testing.expectEqual(@as(c_int, 20 + 3 * 12), scrollScissor(&g, layout, 400, 400).y);
+ // None held: the whole body moves.
+ surface.body_layers[0].rows = 0;
+ try std.testing.expectEqual(@as(u16, 0), holdContext(&g, &surface, 0, 0, 19, layout).rows);
+ try std.testing.expectEqual(@as(c_int, 20), scrollScissor(&g, layout, 400, 400).y);
+}
+
fn scrollScissor(g: *const Gui, layout: CellLayout, sw: u32, sh: u32) c.SDL_Rect {
const r = g.scroll_rect;
const px = layout.x_off + @as(f32, @floatFromInt(r.x + config.GUTTER)) * layout.w;
- const py = layout.y_off + @as(f32, @floatFromInt(g.scroll_body_y)) * layout.h;
+ const py = layout.y_off + @as(f32, @floatFromInt(g.scroll_body_y)) * layout.h + g.scroll_held_px;
const pw = @as(f32, @floatFromInt(r.w - config.GUTTER)) * layout.w;
- const ph = @as(f32, @floatFromInt(r.h - pardes.BOX_H)) * layout.h;
+ const ph = @max(0, @as(f32, @floatFromInt(g.scroll_body_h)) * layout.h - g.scroll_held_px);
const x0 = std.math.clamp(@as(i32, @intFromFloat(@floor(px))), 0, @as(i32, @intCast(sw)));
const y0 = std.math.clamp(@as(i32, @intFromFloat(@floor(py))), 0, @as(i32, @intCast(sh)));
const x1 = std.math.clamp(@as(i32, @intFromFloat(@ceil(px + pw))), x0, @as(i32, @intCast(sw)));
@@ -4423,7 +5698,7 @@ fn snapshotContainsPlacement(g: *const Gui, current: pardes.ImagePlace) bool {
return false;
}
-fn placeIntersectsBox(place: SavedImagePlace, box: pardes.layout.Box) bool {
+fn placeIntersectsBox(place: SavedImagePlace, box: pardes.animation.Box) bool {
const x0: f32 = @floatFromInt(place.x);
const y0: f32 = @floatFromInt(place.y);
const x1: f32 = @floatFromInt(@as(u32, place.x) + place.w);
@@ -4515,6 +5790,23 @@ fn uploadNativeTexture(
const byte_len = validImageBytes(place) orelse return error.BadImage;
const key = place.cacheKey();
if (g.native_images.contains(key)) return;
+ if (comptime pardes.pdf_enabled) if (place.patch) |patch| patch: {
+ // The core changed only these rows since a revision we still hold:
+ // write them into that texture rather than sending the whole page.
+ var base = key;
+ base.revision = patch.from;
+ if (patch.y + patch.h > place.ih) break :patch;
+ const texture = g.native_images.get(base) orelse break :patch;
+ const row = place.iw * 4;
+ try uploadTextureRows(g, cmd, texture, place.rgba[patch.y * row ..][0 .. patch.h * row], place.iw, patch.y, patch.h);
+ try g.native_images.put(gpa, key, texture);
+ _ = g.native_images.remove(base);
+ // A transition snapshot of the last frame follows its texture.
+ for (g.presented_images.items) |*saved| if (saved.key.eql(base)) {
+ saved.key = key;
+ };
+ return;
+ };
var tex_info = std.mem.zeroes(c.SDL_GPUTextureCreateInfo);
tex_info.type = c.SDL_GPU_TEXTURETYPE_2D;
@@ -4527,47 +5819,59 @@ fn uploadNativeTexture(
tex_info.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
const texture = c.SDL_CreateGPUTexture(g.device, &tex_info) orelse return error.GpuCreate;
errdefer c.SDL_ReleaseGPUTexture(g.device, texture);
+ try uploadTextureRows(g, cmd, texture, place.rgba[0..byte_len], place.iw, 0, place.ih);
+ try g.native_images.put(gpa, key, texture);
+}
+/// Copy `rows` rows of RGBA, `width` pixels each, into `texture` at row `y`.
+fn uploadTextureRows(
+ g: *Gui,
+ cmd: *c.SDL_GPUCommandBuffer,
+ texture: *c.SDL_GPUTexture,
+ rgba: []const u8,
+ width: usize,
+ y: usize,
+ rows: usize,
+) !void {
var xf_info = c.SDL_GPUTransferBufferCreateInfo{
.usage = c.SDL_GPU_TRANSFERBUFFERUSAGE_UPLOAD,
- .size = byte_len,
+ .size = @intCast(rgba.len),
.props = 0,
};
const transfer = c.SDL_CreateGPUTransferBuffer(g.device, &xf_info) orelse return error.GpuCreate;
defer c.SDL_ReleaseGPUTransferBuffer(g.device, transfer);
const mapped: [*]u8 = @ptrCast(c.SDL_MapGPUTransferBuffer(g.device, transfer, false) orelse return error.GpuMap);
- @memcpy(mapped[0..byte_len], place.rgba);
+ @memcpy(mapped[0..rgba.len], rgba);
c.SDL_UnmapGPUTransferBuffer(g.device, transfer);
const copy = c.SDL_BeginGPUCopyPass(cmd);
const src = c.SDL_GPUTextureTransferInfo{
.transfer_buffer = transfer,
.offset = 0,
- .pixels_per_row = @intCast(place.iw),
- .rows_per_layer = @intCast(place.ih),
+ .pixels_per_row = @intCast(width),
+ .rows_per_layer = @intCast(rows),
};
const dst = c.SDL_GPUTextureRegion{
.texture = texture,
.mip_level = 0,
.layer = 0,
.x = 0,
- .y = 0,
+ .y = @intCast(y),
.z = 0,
- .w = @intCast(place.iw),
- .h = @intCast(place.ih),
+ .w = @intCast(width),
+ .h = @intCast(rows),
.d = 1,
};
c.SDL_UploadToGPUTexture(copy, &src, &dst, false);
c.SDL_EndGPUCopyPass(copy);
- try g.native_images.put(gpa, key, texture);
}
fn appendPreparedImage(
g: *Gui,
gpa: std.mem.Allocator,
place: SavedImagePlace,
- track: ?pardes.layout.Track,
- clip: ?pardes.layout.Box,
+ track: ?pardes.animation.Track,
+ clip: ?pardes.animation.Box,
old_layer: bool,
) void {
const texture = g.native_images.get(place.key) orelse return;
@@ -4642,7 +5946,7 @@ fn prepareNativeImages(
gpa: std.mem.Allocator,
cmd: *c.SDL_GPUCommandBuffer,
surface: *pardes.Surface,
- plan: *PaintPlan,
+ groups: *Groups,
sw: u32,
sh: u32,
) bool {
@@ -4668,9 +5972,9 @@ fn prepareNativeImages(
}
g.prepared_images.clearRetainingCapacity();
- for (plan.batches[0..plan.len], 0..) |*batch, batch_index| {
- batch.image_start = std.math.cast(u32, g.prepared_images.items.len) orelse return false;
- const track = batch.track;
+ for (groups.items[0..groups.len], 0..) |*group, group_index| {
+ group.image_start = std.math.cast(u32, g.prepared_images.items.len) orelse return false;
+ const track = group.track;
if (track) |active| {
if (active.phase == .closing) {
@@ -4690,7 +5994,7 @@ fn prepareNativeImages(
for (surface.images[0..surface.nimages]) |maybe| {
const current = maybe orelse continue;
if (validImageBytes(current) == null or
- paintBatchForSerial(plan, current.serial) != batch_index) continue;
+ groupOf(groups, current.serial) != group_index) continue;
const saved = SavedImagePlace.from(current);
const current_track = if (track) |active| switch (active.effect) {
.dissolve => if (snapshotContainsPlacement(g, current)) null else active,
@@ -4699,7 +6003,7 @@ fn prepareNativeImages(
appendPreparedImage(g, gpa, saved, current_track, null, false);
}
}
- if (batch_index == 0) for (plan.batches[1..plan.len]) |tracked| {
+ if (group_index == 0) for (groups.items[1..][0..groups.tracks]) |tracked| {
const active = tracked.track.?;
if (active.effect != .vertical or active.phase != .opening) continue;
for (g.presented_images.items) |saved| {
@@ -4708,7 +6012,7 @@ fn prepareNativeImages(
}
};
const image_end = std.math.cast(u32, g.prepared_images.items.len) orelse return false;
- batch.image_count = image_end - batch.image_start;
+ group.image_count = image_end - group.image_start;
}
const capacity = std.math.cast(u32, g.prepared_images.items.len) orelse return false;
@@ -4756,7 +6060,7 @@ fn imageScissor(
};
}
-fn panelBoxScissor(g: *const Gui, box: pardes.layout.Box, max_w: u32, max_h: u32) c.SDL_Rect {
+fn panelBoxScissor(g: *const Gui, box: pardes.animation.Box, max_w: u32, max_h: u32) c.SDL_Rect {
const x0: i32 = @intFromFloat(@floor(box.x * @as(f32, @floatFromInt(g.cell_w))));
const y0: i32 = @intFromFloat(@floor(box.y * @as(f32, @floatFromInt(g.cell_h))));
const x1: i32 = @intFromFloat(@ceil((box.x + box.w) * @as(f32, @floatFromInt(g.cell_w))));
@@ -4777,11 +6081,10 @@ fn drawNativeImagesGpu(
g: *Gui,
rp: ?*c.SDL_GPURenderPass,
surface: *pardes.Surface,
- plan: *const PaintPlan,
- batch_index: usize,
+ batch: Group,
+ whole: c.SDL_Rect,
) void {
const pass = rp orelse return;
- const batch = plan.batches[batch_index];
c.SDL_BindGPUGraphicsPipeline(pass, g.image_pipeline);
const max_w = @as(u32, surface.cols) * g.cell_w;
const max_h = @as(u32, surface.rows) * g.cell_h;
@@ -4800,12 +6103,8 @@ fn drawNativeImagesGpu(
idx += 1;
}
std.debug.assert(idx == batch.image_start + batch.image_count);
- const whole = c.SDL_Rect{
- .x = 0,
- .y = 0,
- .w = @intCast(@as(u32, surface.cols) * g.cell_w),
- .h = @intCast(@as(u32, surface.rows) * g.cell_h),
- };
+ // Back to the whole target: what draws after a picture may run on past
+ // the grid, as a rule and a band do.
c.SDL_SetGPUScissor(pass, &whole);
}
@@ -4814,103 +6113,129 @@ fn renderFrame(
gpa: std.mem.Allocator,
core: ?*const pardes.Pardes,
surface: *pardes.Surface,
- theme_bg: ?[3]u8,
- topbar_pane_border_rgb: [3]u8,
- tagline_rgb: [3]u8,
- scene_effects: pardes.layout.SceneEffect,
debug_on: bool,
) !bool {
if (surface.pointer_shape != g.pointer_shape) {
g.pointer_shape = surface.pointer_shape;
- const cursor = if (g.pointer_shape == .link) g.link_cursor else g.arrow_cursor orelse c.SDL_GetDefaultCursor();
+ const cursor = switch (g.pointer_shape) {
+ .link => g.link_cursor,
+ .box => g.box_cursor orelse g.arrow_cursor,
+ else => g.arrow_cursor orelse c.SDL_GetDefaultCursor(),
+ };
if (cursor) |value| _ = c.SDL_SetCursor(value);
}
g.scene_target_failed = false;
+ g.words.memo = .{}; // positional, and this frame's cells are new
const cmd = c.SDL_AcquireGPUCommandBuffer(g.device) orelse return false;
var command_consumed = false;
defer if (!command_consumed) {
_ = c.SDL_SubmitGPUCommandBuffer(cmd);
};
- var sw: u32 = 0;
- var sh: u32 = 0;
- var target: *c.SDL_GPUTexture = undefined;
- if (g.capture) {
- sw = @as(u32, surface.cols) * g.cell_w;
- sh = @as(u32, surface.rows) * g.cell_h;
- if (sw == 0 or sh == 0) {
- command_consumed = true;
- _ = c.SDL_SubmitGPUCommandBuffer(cmd);
- return false;
- }
- try ensureCaptureTexture(g, sw, sh);
- target = g.capture_tex.?;
- } else if (g.soft_present) {
- var pw: c_int = 0;
- var ph: c_int = 0;
- if (!c.SDL_GetWindowSizeInPixels(g.window, &pw, &ph) or pw <= 0 or ph <= 0) {
- command_consumed = true;
- _ = c.SDL_SubmitGPUCommandBuffer(cmd);
- return false;
- }
- sw = @intCast(pw);
- sh = @intCast(ph);
- try ensureCaptureTexture(g, sw, sh);
- target = g.capture_tex.?;
- } else {
- var swap_tex: ?*c.SDL_GPUTexture = null;
- if (!c.SDL_AcquireGPUSwapchainTexture(cmd, g.window, &swap_tex, &sw, &sh)) {
- command_consumed = true;
- _ = c.SDL_SubmitGPUCommandBuffer(cmd);
- return false;
- }
- target = swap_tex orelse { // swapchain busy: skip the frame
- command_consumed = true;
- _ = c.SDL_SubmitGPUCommandBuffer(cmd);
- return false;
- };
- }
+ const frame_target = try acquireTarget(g, cmd, @as(u32, surface.cols) * g.cell_w + g.capture_pad, @as(u32, surface.rows) * g.cell_h + g.capture_pad) orelse {
+ command_consumed = true;
+ _ = c.SDL_SubmitGPUCommandBuffer(cmd);
+ return false;
+ };
+ const target = frame_target.texture;
+ const sw = frame_target.w;
+ const sh = frame_target.h;
const win_w: f32 = @floatFromInt(sw);
const win_h: f32 = @floatFromInt(sh);
- var scene_on = scene_effects.crt or scene_effects.ripple or scene_effects.glitch;
+ // The post chain runs from the scene texture, over a local frame or an
+ // attached session's alike.
+ var scene_on = g.post.ready();
if (scene_on) ensureSceneTexture(g, sw, sh) catch {
g.scene_target_failed = true;
scene_on = false;
};
const scene: *c.SDL_GPUTexture = if (scene_on) g.scene_tex.? else target;
+ // The frame's CPU side: groups, decor, cover and every instance, up to
+ // their upload.
+ const build_zone = tracy.zone(@src(), "gui frame build");
+ const probe_build = monoNs();
+ var building = true;
+ defer if (building) build_zone.end();
const layout = fixedCellLayout(g);
- var paint_plan = makePaintPlan(surface.panelTracks(), surface.hasPanelDiff());
- var overlay_count = buildOverlay(
- g,
- core,
- surface,
- layout,
- sw,
- sh,
- topbar_pane_border_rgb,
- tagline_rgb,
- paint_plan.len == 1,
- debug_on,
- );
+ const chrome = &surface.chrome;
+ // G6: what the scroll just done moved the pane's rows by, measured on
+ // this frame against the last (the glide follows it from there).
+ if (g.glide.pending) g.glide.measure(gpa, surface);
+ g.sel_glow.now_ns = if (core) |p| p.now_ns else c.SDL_GetTicksNS();
+ // Off, or while panes move, no glow and nothing fading.
+ if (surface.chrome.fx & 1 == 0 or surface.panelTracks().len != 0) g.sel_glow = .{ .now_ns = g.sel_glow.now_ns };
+ g.hover_glow.now_ns = g.sel_glow.now_ns;
+ if (surface.chrome.fx & 2 == 0 or surface.panelTracks().len != 0) g.hover_glow = .{ .now_ns = g.sel_glow.now_ns };
+ if (g.glide.moving()) g.glide.advance(g.glide.now_ns, g.glide.motion);
+ cell_decor = CellDecor.of(chrome);
+ plaque_through_len = 0;
+ // G13: a body's dots follow its text at a quarter of its speed: its
+ // first line, and a glide's picture offset, in rows.
+ if (chrome.fx & 8 != 0 and chrome.decor_dots != null) for (surface.regionList()) |region| {
+ if (region.kind != .body or cell_decor.nbodies == cell_decor.bodies.len) continue;
+ var rows: f32 = @floatFromInt(region.line);
+ if (g.glide.moving() and g.glide.pane == region.owner) rows += g.glide.follow.offset;
+ const period = cell_decor.uniforms[4];
+ cell_decor.bodies[cell_decor.nbodies] = bodyPixels(region, layout);
+ cell_decor.shifts[cell_decor.nbodies] = @mod(-rows * layout.h * 0.25, period);
+ cell_decor.nbodies += 1;
+ };
+ // Plaques need an opaque window: with WindowOpacity under 100 the cells
+ // are drawn as they are, and the plaques not at all.
+ cell_decor.plaques_off = backgroundOpacity(g.applied_window_opacity) < 1;
+ if (chrome.decor_box_border != null and !cell_decor.plaques_off) {
+ cell_decor.grounds = .{ chrome.tag_bg, chrome.tag_focus_bg };
+ for (surface.regionList()) |region| {
+ if (region.kind != .tag and region.kind != .column_tag and region.kind != .workspace_tag) continue;
+ if (cell_decor.nplaques == cell_decor.plaques.len) break;
+ const plaque = plaqueBox(g, chrome, surface.regionList(), region, layout, win_w, win_h) orelse continue;
+ cell_decor.plaques[cell_decor.nplaques] = plaque.band;
+ cell_decor.nplaques += 1;
+ }
+ }
+ var groups = makeGroups(surface.panelTracks(), surface.hasPanelDiff());
+ // While panes move the cells' cursors are not drawn; the focused one is
+ // the overlay's quad, riding with its pane (draw.glideCursor), as it is
+ // while it glides or blinks. One or the other every frame (none only at
+ // a blink's off half).
+ const blink_alpha: f32 = if (blinkNow(g, chrome)) |b| b.alpha else 1;
+ // While a glide moves the text, the caret is its quad, drawn from its
+ // own springs, not a cell of the moving rows.
+ const quad_mode = chrome.cursor_glide & 2 != 0 and (chrome.cursor_glide & 1 != 0 or blink_alpha < 1 or g.glide.follow.offset != 0);
+ g.cursor_quad_alpha = if (quad_mode) chrome.cursor_alpha * blink_alpha else 0;
+ // The probe's view of this frame's motion (FrameStats.Frame).
+ if (core) |p| {
+ const probe = &@constCast(p).frames;
+ // A focused PDF's strip is the core's (pdf_view.draw).
+ const pdf_focus = if (p.panes[p.active]) |pane| pane.hasPdf() else false;
+ if (!pdf_focus) probe.scroll = g.glide.follow.offset;
+ probe.caret = caretRow(g, surface) orelse 0;
+ }
+ const cursors_shown = groups.tracks == 0 and !quad_mode;
+ var overlay_count = buildOverlay(g, core, surface, sw, sh, debug_on);
if (overlay_count != 0 and !uploadOverlayGpu(g, cmd, overlay_count))
overlay_count = 0;
- if (!prepareNativeImages(g, gpa, cmd, surface, &paint_plan, sw, sh)) {
+ if (!prepareNativeImages(g, gpa, cmd, surface, &groups, sw, sh)) {
g.prepared_images.clearRetainingCapacity();
- for (paint_plan.batches[0..paint_plan.len]) |*batch| {
- batch.image_start = 0;
- batch.image_count = 0;
+ for (groups.items[0..groups.len]) |*group| {
+ group.image_start = 0;
+ group.image_count = 0;
}
}
const cells: u32 = @as(u32, surface.cols) * surface.rows;
+ try g.cover.resize(gpa, @as(usize, cells) * 2);
+ const covered = g.cover.items[0..cells];
+ coverFrame(covered, surface.cols, surface.rows, surface.bodyLayers(), surface.tagLayers(), surface.regionList());
+ // Only a panel transition paints the grid under the layers it leaves.
+ const previous_covered = g.cover.items[cells..];
+ if (groups.tracks != 0)
+ coverFrame(previous_covered, surface.cols, surface.rows, surface.previous_body_layers, surface.previous_tag_layers, surface.previous_regions);
+ try buildDecor(g, gpa, surface, &groups, layout, win_w, win_h, cursors_shown);
- const page = ground(theme_bg, g.transparent);
+ const page: Ground = .opaqueRgb(chrome.page orelse bg_default);
const background_opacity = backgroundOpacity(g.applied_window_opacity);
- const tagline_base = pardes.Cell{
- .style = .{ .bg = .{ .rgb = tagline_rgb }, .font_role = .tagline },
- .default = false,
- };
var color_target = std.mem.zeroes(c.SDL_GPUColorTargetInfo);
color_target.texture = scene;
color_target.clear_color = if (page.clear) .{ .r = 0, .g = 0, .b = 0, .a = 0 } else .{
@@ -4927,28 +6252,21 @@ fn renderFrame(
while (row < surface.rows) : (row += 1) {
var col: u16 = 0;
while (col < surface.cols) : (col += 1) {
- if (bodyLayerAt(surface, col, row) != null or tagLayerIn(surface.tagLayers(), col, row) != null) continue;
- const batch_index = paintBatchAt(&paint_plan, col, row);
- const track = paint_plan.batches[batch_index].track;
- const data_effect = if (track) |active|
- active.effect == .dissolve
- else
- false;
- const data_diff = data_effect and gripCellChanged(surface, col, row);
- const logical_idx: u32 = @as(u32, row) * surface.cols + col;
+ const at = @as(usize, row) * surface.cols + col;
+ if (covered[at].layer and !covered[at].floating) continue;
+ const group_index = if (covered[at].floating) groups.guides else groupAt(&groups, col, row);
+ const track = groups.items[group_index].track;
+ const data_effect = if (track) |active| active.effect == .dissolve else false;
+ const data_diff = data_effect and gripCellChanged(surface, covered, previous_covered, col, row);
const instance_count = if (data_diff)
- cellInstanceCount(&surface.previous_cells[logical_idx]) + cellInstanceCount(surface.at(col, row))
+ cellInstanceCount(&surface.previous_cells[at]) + cellInstanceCount(&surface.cells[at])
else
- cellInstanceCount(surface.at(col, row));
- paint_plan.batches[batch_index].cell_count = std.math.add(
- u32,
- paint_plan.batches[batch_index].cell_count,
- instance_count,
- ) catch return error.GpuCapacity;
+ cellInstanceCount(&surface.cells[at]);
+ groups.items[group_index].cell_count = std.math.add(u32, groups.items[group_index].cell_count, instance_count) catch return error.GpuCapacity;
}
}
- for (paint_plan.batches[1..paint_plan.len]) |*batch| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks]) |*group| {
+ const track = group.track.?;
const duplicate_under = track.effect == .vertical and track.phase == .opening;
if (!duplicate_under and track.phase != .closing) continue;
row = 0;
@@ -4956,33 +6274,29 @@ fn renderFrame(
var col: u16 = 0;
while (col < surface.cols) : (col += 1) {
if (!boxContains(track.contentBox(), col, row)) continue;
- if (bodyLayerIn(surface.previous_body_layers, col, row) != null or tagLayerIn(surface.previous_tag_layers, col, row) != null) continue;
- const destination = if (duplicate_under) &paint_plan.batches[0] else batch;
- const logical_idx: u32 = @as(u32, row) * surface.cols + col;
- destination.cell_count = std.math.add(
- u32,
- destination.cell_count,
- cellInstanceCount(&surface.previous_cells[logical_idx]),
- ) catch return error.GpuCapacity;
+ const at = @as(usize, row) * surface.cols + col;
+ if (previous_covered[at].layer) continue;
+ const destination = if (duplicate_under) &groups.items[0] else group;
+ destination.cell_count = std.math.add(u32, destination.cell_count, cellInstanceCount(&surface.previous_cells[at])) catch return error.GpuCapacity;
}
}
}
for (surface.bodyLayers()) |*layer| {
if (layer.rows == 0) continue;
- const batch = &paint_plan.batches[paintBatchAt(&paint_plan, layer.viewport.x, layer.viewport.y)];
+ const group = &groups.items[groupAt(&groups, layer.viewport.x, layer.viewport.y)];
const bottom = @as(f32, @floatFromInt(layer.viewport.y + layer.viewport.h)) * layout.h;
for (0..layer.rows) |lr| {
if (layer.rowTop(@intCast(lr), layout.h, @floatFromInt(g.tagline_height)) >= bottom) break;
- batch.cell_count += layer.cols + @as(u32, if (lr < layer.context_rows) 1 else 0) + @as(u32, @intFromBool(layer.hasContextBorderAfter(lr)));
+ group.cell_count += layer.cols + @as(u32, if (lr < layer.context_rows) 1 else 0) + @as(u32, @intFromBool(layer.hasContextBorderAfter(lr)));
}
}
- for (paint_plan.batches[1..paint_plan.len], 1..) |batch, batch_index| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ const track = group.track.?;
const under = track.effect == .vertical and track.phase == .opening;
if (!under and track.phase != .closing and track.effect != .dissolve) continue;
for (surface.previous_body_layers) |*layer| {
if (layer.rows == 0 or layer.serial != track.serial) continue;
- const destination = if (under) &paint_plan.batches[0] else &paint_plan.batches[batch_index];
+ const destination = &groups.items[if (under) 0 else index];
const bottom = @as(f32, @floatFromInt(layer.viewport.y + layer.viewport.h)) * layout.h;
for (0..layer.rows) |lr| {
if (layer.rowTop(@intCast(lr), layout.h, @floatFromInt(g.tagline_height)) >= bottom) break;
@@ -4991,29 +6305,30 @@ fn renderFrame(
}
}
for (surface.tagLayers()) |*layer| {
- if (layer.cols == 0) continue;
- const batch = &paint_plan.batches[paintBatchAt(&paint_plan, layer.viewport.x, layer.viewport.y)];
- batch.cell_count += tagLayerCellCount(g, layer) + 1;
+ if (layer.rows == 0) continue;
+ const group_index = if (layer.kind == .notice) noticeGroup(&groups, layer) else groupAt(&groups, layer.viewport.x, layer.viewport.y);
+ groups.items[group_index].cell_count += (tagLayerCellCount(g, layer) + 1) * layer.rows;
}
- for (paint_plan.batches[1..paint_plan.len], 1..) |batch, batch_index| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ const track = group.track.?;
const under = track.effect == .vertical and track.phase == .opening;
if (!under and track.phase != .closing and track.effect != .dissolve) continue;
for (surface.previous_tag_layers) |*layer| {
- if (layer.cols == 0 or layer.kind != .pane or layer.serial != track.serial) continue;
- const destination = if (under) &paint_plan.batches[0] else &paint_plan.batches[batch_index];
- destination.cell_count += tagLayerCellCount(g, layer) + 1;
+ if (layer.rows == 0 or layer.kind != .pane or layer.serial != track.serial) continue;
+ groups.items[if (under) 0 else index].cell_count += (tagLayerCellCount(g, layer) + 1) * layer.rows;
}
}
- var cell_next: [pardes.MAX_PANES * 2 + 1]u32 = @splat(0);
+ var cell_next: [pardes.MAX_PANES * 2 + 4]u32 = @splat(0);
var cell_total: u32 = 0;
- for (paint_plan.batches[0..paint_plan.len], 0..) |*batch, batch_index| {
- batch.cell_start = cell_total;
- cell_next[batch_index] = cell_total;
- cell_total = std.math.add(u32, cell_total, batch.cell_count) catch return error.GpuCapacity;
+ for (groups.items[0..groups.len], 0..) |*group, index| {
+ group.cell_start = cell_total;
+ cell_next[index] = cell_total;
+ cell_total = std.math.add(u32, cell_total, group.cell_count) catch return error.GpuCapacity;
}
- if (cell_total != 0) {
- const capacity = std.math.add(u32, cell_total, cells) catch return error.GpuCapacity;
+ const decor_len: u32 = @intCast(g.decor.items.len);
+ if (cell_total != 0 or decor_len != 0) {
+ // The shifted rows of a scroll: its body, and a glide's rows past it.
+ const capacity = std.math.add(u32, cell_total, 2 * cells + decor_len) catch return error.GpuCapacity;
try ensureVbuf(g, capacity);
const vptr: [*]u8 = @ptrCast(c.SDL_MapGPUTransferBuffer(g.device, g.vxfer.?, false) orelse {
@@ -5026,89 +6341,99 @@ fn renderFrame(
const cursor_bar = if (surface.cursor) |cu| cu.bar else false;
row = 0;
while (row < surface.rows) : (row += 1) {
+ const line = surface.cells[@as(usize, row) * surface.cols ..][0..surface.cols];
+ const line_cover = covered[@as(usize, row) * surface.cols ..][0..surface.cols];
+ const line_cursor: ?usize = if (surface.cursor) |cu| if (cu.y == row) cu.x else null else null;
var col: u16 = 0;
while (col < surface.cols) : (col += 1) {
- if (bodyLayerAt(surface, col, row) != null or tagLayerIn(surface.tagLayers(), col, row) != null) continue;
- const batch_index = paintBatchAt(&paint_plan, col, row);
- const track = paint_plan.batches[batch_index].track;
- const logical_idx: u32 = @as(u32, row) * surface.cols + col;
- const data_effect = if (track) |active|
- active.effect == .dissolve
- else
- false;
- const data_diff = data_effect and gripCellChanged(surface, col, row);
- if (data_diff) {
- emitSurfaceCell(
- g,
- core,
- instances,
- &cell_next[batch_index],
- col,
- row,
- layout,
- win_w,
- win_h,
- track,
- &surface.previous_cells[logical_idx],
- &tagline_base,
- paneGripCell(surface.previous_tag_layers, surface.previous_cells, surface.cols, col, row),
- true,
- false,
- page,
- );
- }
+ const at = @as(usize, row) * surface.cols + col;
+ if (covered[at].layer and !covered[at].floating) continue;
+ const group_index = if (covered[at].floating) groups.guides else groupAt(&groups, col, row);
+ const track = groups.items[group_index].track;
+ const data_effect = if (track) |active| active.effect == .dissolve else false;
+ const data_diff = data_effect and gripCellChanged(surface, covered, previous_covered, col, row);
+ // The new cell, then (a dissolve) the old one fading out over
+ // it, as the old layers come after the new ones.
emitSurfaceCell(
g,
- core,
+ chrome,
instances,
- &cell_next[batch_index],
+ &cell_next[group_index],
col,
row,
layout,
win_w,
win_h,
if (data_effect and !data_diff) null else track,
- surface.at(col, row),
- &tagline_base,
- paneGripCell(surface.tagLayers(), surface.cells, surface.cols, col, row),
+ line,
+ line_cover,
+ col,
+ line_cursor,
+ false,
+ cursors_shown and at == cursor_idx and !cursor_bar and bodyLayerAt(surface, col, row) == null,
+ page,
+ );
+ if (data_diff) emitSurfaceCell(
+ g,
+ chrome,
+ instances,
+ &cell_next[group_index],
+ col,
+ row,
+ layout,
+ win_w,
+ win_h,
+ track,
+ surface.previous_cells[@as(usize, row) * surface.cols ..][0..surface.cols],
+ previous_covered[@as(usize, row) * surface.cols ..][0..surface.cols],
+ col,
+ null,
+ true,
false,
- paint_plan.len == 1 and logical_idx == cursor_idx and !cursor_bar and bodyLayerAt(surface, col, row) == null,
page,
);
}
}
+ // Body layers first: a notice chip over a tree-sitter context band
+ // is a tag layer, and instances paint in emission order.
+ for (surface.bodyLayers()) |*layer| {
+ if (layer.rows == 0) continue;
+ const group_index = groupAt(&groups, layer.viewport.x, layer.viewport.y);
+ emitBodyLayer(g, instances, &cell_next[group_index], layer, win_w, win_h, groups.items[group_index].track, page, cursors_shown, false, chrome.topbar_rule);
+ }
for (surface.tagLayers()) |*layer| {
- if (layer.cols == 0) continue;
- const batch_index = paintBatchAt(&paint_plan, layer.viewport.x, layer.viewport.y);
- emitTagLayer(g, instances, &cell_next[batch_index], layer, win_w, win_h, paint_plan.batches[batch_index].track, page, paint_plan.len == 1, false);
+ if (layer.rows == 0) continue;
+ const track_index = groupAt(&groups, layer.viewport.x, layer.viewport.y);
+ // A notice floats over the panes, moving with its own.
+ const group_index = if (layer.kind == .notice) noticeGroup(&groups, layer) else track_index;
+ const start = cell_next[group_index];
+ emitTagLayer(g, instances, &cell_next[group_index], layer, win_w, win_h, groups.items[track_index].track, page, cursors_shown, false);
+ // A notice dropping past its row (a flavour's overshoot) stays
+ // inside its pane's body.
+ if (layer.kind == .notice and layer.slide > 0) if (bodyBottom(surface, layer.id, layout)) |bottom| {
+ for (instances[start..cell_next[group_index]]) |*instance| clipInstance(instance, .{ -1e9, -1e9, 1e9, bottom }, win_w, win_h);
+ };
}
- for (paint_plan.batches[1..paint_plan.len], 1..) |batch, batch_index| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ const track = group.track.?;
const under = track.effect == .vertical and track.phase == .opening;
if (!under and track.phase != .closing and track.effect != .dissolve) continue;
for (surface.previous_tag_layers) |*layer| {
- if (layer.cols == 0 or layer.kind != .pane or layer.serial != track.serial) continue;
- const destination: usize = if (under) 0 else batch_index;
- emitTagLayer(g, instances, &cell_next[destination], layer, win_w, win_h, if (under) null else track, page, false, track.effect == .dissolve);
+ if (layer.rows == 0 or layer.kind != .pane or layer.serial != track.serial) continue;
+ emitTagLayer(g, instances, &cell_next[if (under) 0 else index], layer, win_w, win_h, if (under) null else track, page, false, track.effect == .dissolve);
}
}
- for (surface.bodyLayers()) |*layer| {
- if (layer.rows == 0) continue;
- const batch_index = paintBatchAt(&paint_plan, layer.viewport.x, layer.viewport.y);
- emitBodyLayer(g, instances, &cell_next[batch_index], layer, win_w, win_h, paint_plan.batches[batch_index].track, page, paint_plan.len == 1, false, topbar_pane_border_rgb);
- }
- for (paint_plan.batches[1..paint_plan.len], 1..) |batch, batch_index| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ const track = group.track.?;
const under = track.effect == .vertical and track.phase == .opening;
if (!under and track.phase != .closing and track.effect != .dissolve) continue;
for (surface.previous_body_layers) |*layer| {
if (layer.rows == 0 or layer.serial != track.serial) continue;
- const destination: usize = if (under) 0 else batch_index;
- emitBodyLayer(g, instances, &cell_next[destination], layer, win_w, win_h, if (under) null else track, page, false, track.effect == .dissolve, topbar_pane_border_rgb);
+ emitBodyLayer(g, instances, &cell_next[if (under) 0 else index], layer, win_w, win_h, if (under) null else track, page, false, track.effect == .dissolve, chrome.topbar_rule);
}
}
- for (paint_plan.batches[1..paint_plan.len], 1..) |batch, batch_index| {
- const track = batch.track.?;
+ for (groups.items[1..][0..groups.tracks], 1..) |group, index| {
+ const track = group.track.?;
const duplicate_under = track.effect == .vertical and track.phase == .opening;
if (!duplicate_under and track.phase != .closing) continue;
row = 0;
@@ -5116,23 +6441,22 @@ fn renderFrame(
var col: u16 = 0;
while (col < surface.cols) : (col += 1) {
if (!boxContains(track.contentBox(), col, row)) continue;
- if (bodyLayerIn(surface.previous_body_layers, col, row) != null or tagLayerIn(surface.previous_tag_layers, col, row) != null) continue;
- const logical_idx: u32 = @as(u32, row) * surface.cols + col;
- const destination: usize = if (duplicate_under) 0 else batch_index;
+ if (previous_covered[@as(usize, row) * surface.cols + col].layer) continue;
emitSurfaceCell(
g,
- core,
+ chrome,
instances,
- &cell_next[destination],
+ &cell_next[if (duplicate_under) 0 else index],
col,
row,
layout,
win_w,
win_h,
if (duplicate_under) null else track,
- &surface.previous_cells[logical_idx],
- &tagline_base,
- paneGripCell(surface.previous_tag_layers, surface.previous_cells, surface.cols, col, row),
+ surface.previous_cells[@as(usize, row) * surface.cols ..][0..surface.cols],
+ previous_covered[@as(usize, row) * surface.cols ..][0..surface.cols],
+ col,
+ null,
false,
false,
page,
@@ -5140,119 +6464,175 @@ fn renderFrame(
}
}
}
- for (paint_plan.batches[0..paint_plan.len], 0..) |batch, batch_index|
- std.debug.assert(cell_next[batch_index] == batch.cell_start + batch.cell_count);
- shifted = emitScrollRows(g, instances, cell_total, surface, layout, win_w, win_h, page);
+ for (groups.items[0..groups.len], 0..) |group, index|
+ std.debug.assert(cell_next[index] == group.cell_start + group.cell_count);
+ // The body's context rows, which its scroll leaves where they are.
+ const scrolling: ?usize = if (g.glide.follow.offset != 0) g.glide.pane else g.scroll_pane;
+ const held: u16 = if (core) |p| if (scrolling) |id| if (p.panes[id]) |pane| pane.context_rows else 0 else 0 else 0;
+ shifted = emitScrollRows(g, instances, cell_total, surface, layout, win_w, win_h, page, held);
+ // Over a theme's plaques a see-through cell with no ink blends to
+ // the plaque under it, so it draws nothing: its quad goes, and the
+ // cells are drawn unblended (a third of the GPU's frame at 4K)
+ // unless one see-through cell does have ink, or the page itself is
+ // see-through.
+ if (cell_decor.nplaques != 0) {
+ const space_u = @as(f32, @floatFromInt(g.space_slot.u)) / @as(f32, @floatFromInt(atlas_w));
+ const space_v = @as(f32, @floatFromInt(g.space_slot.v)) / @as(f32, @floatFromInt(atlas_h));
+ if (page.clear or plaque_through_len > plaque_through.len) cell_decor.inked_clear = true;
+ for (plaque_through[0..@min(plaque_through_len, plaque_through.len)]) |at| {
+ const instance = &instances[at];
+ // A grip's button takes its cell's ground back (emitSurfaceCell).
+ if (instance.effect & clear_bg_bit == 0) continue;
+ if (instance.u0 == space_u and instance.v0 == space_v) {
+ instance.x1 = instance.x0;
+ instance.y1 = instance.y0;
+ } else cell_decor.inked_clear = true;
+ }
+ }
+ @memcpy(instances[cell_total + shifted ..][0..decor_len], g.decor.items);
c.SDL_UnmapGPUTransferBuffer(g.device, g.vxfer.?);
- if (g.atlas_dirty) uploadAtlas(g, cmd);
+ if (g.atlas_dirty_top < g.atlas_dirty_bottom) uploadAtlas(g, cmd);
const copy = c.SDL_BeginGPUCopyPass(cmd);
const src = c.SDL_GPUTransferBufferLocation{ .transfer_buffer = g.vxfer.?, .offset = 0 };
- const dst = c.SDL_GPUBufferRegion{ .buffer = g.vbuf.?, .offset = 0, .size = (cell_total + shifted) * @sizeOf(CellInstance) };
+ const dst = c.SDL_GPUBufferRegion{ .buffer = g.vbuf.?, .offset = 0, .size = (cell_total + shifted + decor_len) * @sizeOf(CellInstance) };
c.SDL_UploadToGPUBuffer(copy, &src, &dst, false);
c.SDL_EndGPUCopyPass(copy);
}
+ build_zone.end();
+ building = false;
+ if (frame_probe) |probe| probe.zone(.gui_build, probe_build);
const rp = c.SDL_BeginGPURenderPass(cmd, &color_target, 1, null);
pushLayerOpacity(cmd, rp, background_opacity);
const whole = c.SDL_Rect{ .x = 0, .y = 0, .w = @intCast(sw), .h = @intCast(sh) };
- for (paint_plan.batches[0..paint_plan.len], 0..) |batch, batch_index| {
- const has_shifted = batch_index == 0 and shifted != 0;
- if ((batch.cell_count != 0 or has_shifted) and g.vbuf != null) {
- c.SDL_BindGPUGraphicsPipeline(rp, g.pipeline);
+ const decor_base = cell_total + shifted;
+ for (groups.items[0..groups.len], 0..) |group, index| {
+ if (group.under_count != 0 and g.vbuf != null) {
+ c.SDL_BindGPUGraphicsPipeline(rp, g.decor_pipeline);
+ pushLayerOpacity(cmd, rp, background_opacity);
+ const binding = c.SDL_GPUBufferBinding{ .buffer = g.vbuf.?, .offset = (decor_base + group.decor_start) * @sizeOf(CellInstance) };
+ c.SDL_BindGPUVertexBuffers(rp, 0, &binding, 1);
+ c.SDL_DrawGPUPrimitives(rp, 6, group.under_count, 0, 0);
+ }
+ const has_shifted = index == 0 and shifted != 0;
+ if ((group.cell_count != 0 or has_shifted) and g.vbuf != null) {
+ // Blended over what is under: a theme's plaques show through
+ // blank tag cells; a dissolve's old cells fade over its new.
+ const dissolving = if (group.track) |active| active.effect == .dissolve else false;
+ c.SDL_BindGPUGraphicsPipeline(rp, if (cell_decor.inked_clear or dissolving) g.pipeline_over else g.pipeline);
const samp_binding = c.SDL_GPUTextureSamplerBinding{ .texture = g.atlas_tex, .sampler = g.atlas_sampler };
c.SDL_BindGPUFragmentSamplers(rp, 0, &samp_binding, 1);
- if (batch.cell_count != 0) {
- const panel_clipped = if (batch.track) |active| active.effect == .vertical else false;
- if (panel_clipped) {
- const clip = panelBoxScissor(g, batch.track.?.contentBox(), sw, sh);
- c.SDL_SetGPUScissor(rp, &clip);
- }
- const binding = c.SDL_GPUBufferBinding{
- .buffer = g.vbuf.?,
- .offset = batch.cell_start * @sizeOf(CellInstance),
- };
+ if (group.cell_count != 0) {
+ const binding = c.SDL_GPUBufferBinding{ .buffer = g.vbuf.?, .offset = group.cell_start * @sizeOf(CellInstance) };
c.SDL_BindGPUVertexBuffers(rp, 0, &binding, 1);
- c.SDL_DrawGPUPrimitives(rp, 6, batch.cell_count, 0, 0);
- if (panel_clipped) c.SDL_SetGPUScissor(rp, &whole);
+ c.SDL_DrawGPUPrimitives(rp, 6, group.cell_count, 0, 0);
}
if (has_shifted) {
const clip = scrollScissor(g, layout, sw, sh);
c.SDL_SetGPUScissor(rp, &clip);
- const binding = c.SDL_GPUBufferBinding{
- .buffer = g.vbuf.?,
- .offset = cell_total * @sizeOf(CellInstance),
- };
+ const binding = c.SDL_GPUBufferBinding{ .buffer = g.vbuf.?, .offset = cell_total * @sizeOf(CellInstance) };
c.SDL_BindGPUVertexBuffers(rp, 0, &binding, 1);
c.SDL_DrawGPUPrimitives(rp, 6, shifted, 0, 0);
c.SDL_SetGPUScissor(rp, &whole);
}
}
- if (batch.image_count != 0)
- drawNativeImagesGpu(g, rp, surface, &paint_plan, batch_index);
+ if (group.image_count != 0) drawNativeImagesGpu(g, rp, surface, group, whole);
+ if (group.decor_count > group.under_count and g.vbuf != null) {
+ c.SDL_BindGPUGraphicsPipeline(rp, g.decor_pipeline);
+ // Ink keeps its colour at any WindowOpacity.
+ pushLayerOpacity(cmd, rp, if (index == groups.ink) 1 else background_opacity);
+ const binding = c.SDL_GPUBufferBinding{ .buffer = g.vbuf.?, .offset = (decor_base + group.decor_start + group.under_count) * @sizeOf(CellInstance) };
+ c.SDL_BindGPUVertexBuffers(rp, 0, &binding, 1);
+ c.SDL_DrawGPUPrimitives(rp, 6, group.decor_count - group.under_count, 0, 0);
+ }
}
drawOverlayGpu(g, cmd, rp, overlay_count);
c.SDL_EndGPURenderPass(rp);
- var rendered_scene: crt.Frame = .{};
if (scene_on) {
- var crt_target = std.mem.zeroes(c.SDL_GPUColorTargetInfo);
- crt_target.texture = target;
- crt_target.load_op = c.SDL_GPU_LOADOP_DONT_CARE;
- crt_target.store_op = c.SDL_GPU_STOREOP_STORE;
- const crt_pass = c.SDL_BeginGPURenderPass(cmd, &crt_target, 1, null);
- c.SDL_BindGPUGraphicsPipeline(crt_pass, g.crt_pipeline);
- const samp_binding = c.SDL_GPUTextureSamplerBinding{ .texture = g.scene_tex.?, .sampler = g.linear_sampler };
- c.SDL_BindGPUFragmentSamplers(crt_pass, 0, &samp_binding, 1);
- const now_ns = c.SDL_GetTicksNS();
- const time_wrap_ns: u64 = 4096 * std.time.ns_per_s;
- const time_seconds: f32 = @floatCast(
- @as(f64, @floatFromInt(now_ns % time_wrap_ns)) / @as(f64, std.time.ns_per_s),
- );
- rendered_scene = .{
- .effects = .{
- .crt = scene_effects.crt,
- .ripple = scene_effects.ripple,
- .glitch = scene_effects.glitch,
- },
- .time_seconds = time_seconds,
- };
- const crt_uniforms = [8]f32{
- time_seconds,
- @floatFromInt((now_ns / (std.time.ns_per_s / 60)) % 65_536),
- @floatFromInt(sw),
- @floatFromInt(sh),
- @floatFromInt(@intFromBool(scene_effects.crt)),
- @floatFromInt(@intFromBool(scene_effects.ripple)),
- @floatFromInt(@intFromBool(scene_effects.glitch)),
- 0,
+ var boxes: [max_cursors]CursorBox = undefined;
+ const cursors = if (cursors_shown) cursorBoxes(g, surface, layout, win_h, &boxes) else 0;
+ var spare: [Post.max_spare][4]f32 = undefined;
+ g.post.describe(.{
+ .cursor = if (cursors > 0) boxes[0] else null,
+ .spare = spare[0..postSpare(surface, layout, &spare)],
+ .background = chrome.page orelse bg_default,
+ .foreground = chrome.fg orelse fg_default,
+ .selection_foreground = if (core) |p| p.theme().sel_fg else chrome.sel_fg,
+ .selection_background = if (core) |p| p.theme().sel_bg else chrome.sel_bg,
+ });
+ const chain_zone = tracy.zone(@src(), "post chain");
+ defer chain_zone.end();
+ g.post.scale = display_scale;
+ g.post.draw(g.device, cmd, g.linear_sampler, g.swapchain_format, g.scene_tex.?, target, sw, sh, c.SDL_GetTicksNS(), background_opacity >= 1) catch {
+ g.scene_target_failed = true;
};
- c.SDL_PushGPUFragmentUniformData(cmd, 0, &crt_uniforms, @sizeOf(@TypeOf(crt_uniforms)));
- c.SDL_DrawGPUPrimitives(crt_pass, 3, 1, 0, 0);
- c.SDL_EndGPURenderPass(crt_pass);
}
+ command_consumed = true;
+ const shown = try finishFrame(g, gpa, cmd, frame_target, if (groups.tracks != 0) groups.items[1].track.?.frame else null);
+ if (shown and groups.tracks == 0) rememberPresentedImages(g, gpa, surface);
+ return shown;
+}
+
+const Target = struct { texture: *c.SDL_GPUTexture, w: u32, h: u32 };
+
+/// What this frame draws into: the capture texture in test mode (the grid's
+/// size plus PARDES_TEST_PAD) or with a soft presenter, else the swapchain's
+/// image; null when there is none to be had this time.
+fn acquireTarget(g: *Gui, cmd: *c.SDL_GPUCommandBuffer, capture_w: u32, capture_h: u32) !?Target {
if (g.capture) {
- command_consumed = true;
- try captureFrame(g, gpa, cmd, target, sw, sh);
- g.presented_scene = rendered_scene;
- if (paint_plan.len == 1) rememberPresentedImages(g, gpa, surface);
+ if (capture_w == 0 or capture_h == 0) return null;
+ try ensureCaptureTexture(g, capture_w, capture_h);
+ return .{ .texture = g.capture_tex.?, .w = capture_w, .h = capture_h };
+ }
+ if (g.soft_present) {
+ var pw: c_int = 0;
+ var ph: c_int = 0;
+ if (!c.SDL_GetWindowSizeInPixels(g.window, &pw, &ph) or pw <= 0 or ph <= 0) return null;
+ try ensureCaptureTexture(g, @intCast(pw), @intCast(ph));
+ return .{ .texture = g.capture_tex.?, .w = @intCast(pw), .h = @intCast(ph) };
+ }
+ var swap_tex: ?*c.SDL_GPUTexture = null;
+ var sw: u32 = 0;
+ var sh: u32 = 0;
+ if (!c.SDL_AcquireGPUSwapchainTexture(cmd, g.window, &swap_tex, &sw, &sh)) return null;
+ // A busy swapchain skips the frame.
+ return .{ .texture = swap_tex orelse return null, .w = sw, .h = sh };
+}
+
+/// Submits the frame: captured, handed to the soft presenter, or presented.
+fn finishFrame(g: *Gui, gpa: std.mem.Allocator, cmd: *c.SDL_GPUCommandBuffer, target: Target, transition: ?u16) !bool {
+ if (g.capture) {
+ try captureFrame(g, gpa, cmd, target.texture, target.w, target.h, transition);
return true;
}
if (g.soft_present) {
- command_consumed = true;
- try softPresentFrame(g, cmd, target, sw, sh);
- g.presented_scene = rendered_scene;
- if (paint_plan.len == 1) rememberPresentedImages(g, gpa, surface);
+ try softPresentFrame(g, cmd, target.texture, target.w, target.h);
return true;
}
- command_consumed = true;
- const submitted = c.SDL_SubmitGPUCommandBuffer(cmd);
- if (submitted) {
- g.presented_scene = rendered_scene;
- if (paint_plan.len == 1) rememberPresentedImages(g, gpa, surface);
+ return c.SDL_SubmitGPUCommandBuffer(cmd);
+}
+
+/// Redraw level A (docs §5.5): the post chain alone, over the frame the core
+/// last drew, for a pass that moves on its own. No core render, no cell.
+fn redrawPost(g: *Gui, gpa: std.mem.Allocator) void {
+ const scene = g.scene_tex orelse return;
+ const cmd = c.SDL_AcquireGPUCommandBuffer(g.device) orelse return;
+ const target = (acquireTarget(g, cmd, g.scene_tex_w, g.scene_tex_h) catch null) orelse {
+ _ = c.SDL_SubmitGPUCommandBuffer(cmd);
+ return;
+ };
+ // A window the retained frame no longer fits waits for the core's.
+ if (target.w != g.scene_tex_w or target.h != g.scene_tex_h) {
+ _ = c.SDL_SubmitGPUCommandBuffer(cmd);
+ return;
}
- return submitted;
+ const zone = tracy.zone(@src(), "post chain redraw");
+ g.post.draw(g.device, cmd, g.linear_sampler, g.swapchain_format, scene, target.texture, target.w, target.h, c.SDL_GetTicksNS(), backgroundOpacity(g.applied_window_opacity) >= 1) catch {};
+ zone.end();
+ _ = finishFrame(g, gpa, cmd, target, null) catch {};
}
const ResolvedCell = struct {
@@ -5266,44 +6646,24 @@ const ResolvedCell = struct {
const topbarPaneBorderPixels = pardes.topbarPaneBorderPixels;
const taglineBandOffset = pardes.taglineBandOffset;
-fn topbarPaneBorderHeight(surface: *const pardes.Surface, cell_h: u32, tagline_h: u32) ?u32 {
- if (surface.rows <= pardes.TOPBAR_H) return null;
- const height = topbarPaneBorderPixels(cell_h, tagline_h);
- if (height == 0) return null;
- const base = @as(usize, pardes.TOPBAR_H) * surface.cols;
- for (surface.cells[base..][0..surface.cols]) |cell|
- if (!cell.default and cell.style.font_role == .tagline) return height;
- return null;
-}
-
-fn bottomTaglinePresent(surface: *const pardes.Surface) bool {
- if (surface.rows == 0) return false;
- const base = @as(usize, surface.rows - 1) * surface.cols;
- for (surface.cells[base..][0..surface.cols]) |cell|
- if (!cell.default and cell.style.font_role == .tagline) return true;
- return false;
-}
-
-test "tagline bands face the topbar rule and Tagbottom faces the window edge" {
+test "tagline bands center in their cells and Tagbottom faces the window edge" {
const cell_h: u32 = 20;
const tagline_h: u32 = 16;
const canvas_h: f32 = 200;
- const border = topbarPaneBorderPixels(cell_h, tagline_h);
- try std.testing.expectEqual(@as(u32, 1), border);
- try std.testing.expectEqual(@as(u32, 4), taglineBandOffset(0, canvas_h, cell_h, tagline_h, true));
- try std.testing.expectEqual(@as(u32, 2), taglineBandOffset(0, canvas_h, cell_h, tagline_h, false));
- try std.testing.expectEqual(@as(u32, 1), taglineBandOffset(1, canvas_h, cell_h, tagline_h, true));
- try std.testing.expectEqual(@as(u32, 2), taglineBandOffset(1, canvas_h, cell_h, tagline_h, false));
- try std.testing.expectEqual(@as(u32, 2), taglineBandOffset(5, canvas_h, cell_h, tagline_h, true));
- try std.testing.expectEqual(@as(u32, 4), taglineBandOffset(9, canvas_h, cell_h, tagline_h, true));
+ // Workspace, column and pane rows alike: text lines up across bands.
+ for ([_]u16{ 0, 1, 2, 5, 8 }) |row|
+ try std.testing.expectEqual(@as(u32, 2), taglineBandOffset(row, canvas_h, cell_h, tagline_h));
+ try std.testing.expectEqual(@as(u32, 4), taglineBandOffset(9, canvas_h, cell_h, tagline_h));
}
-fn resolveCell(g: *Gui, cell: *const pardes.Cell, role: pardes.FontRole, is_cursor: bool, page: Ground) ResolvedCell {
+/// The colours and atlas slot of `line[at]`. `cursor` is where the cursor sits
+/// in `line`, block or bar: shaping breaks around it.
+fn resolveCell(g: *Gui, line: []const pardes.Cell, at: usize, cursor: ?usize, role: pardes.FontRole, is_cursor: bool, page: Ground) ResolvedCell {
+ const cell = &line[at];
var fg = fg_default;
var bg = page.rgb;
var clear_bg = page.clear;
var reverse = is_cursor;
- var blank = false;
if (!cell.default) {
const st = cell.style;
fg = switch (st.fg) {
@@ -5326,8 +6686,8 @@ fn resolveCell(g: *Gui, cell: *const pardes.Cell, role: pardes.FontRole, is_curs
if (st.invisible) {
fg = bg;
// With a translucent background, painting bg-colored glyphs at
- // full opacity would expose text that the terminal concealed.
- blank = true;
+ // full opacity would expose text that the terminal concealed, so
+ // cellSlot draws a concealed cell blank.
}
if (st.dim) for (&fg) |*ch| {
ch.* = @intCast(@as(u16, ch.*) * 6 / 10);
@@ -5338,10 +6698,8 @@ fn resolveCell(g: *Gui, cell: *const pardes.Cell, role: pardes.FontRole, is_curs
clear_bg = false;
}
- const cp = if (blank) ' ' else cellCodepoint(cell);
- const decoration = GlyphDecoration.fromCell(cell);
return .{
- .slot = if (cp == ' ' and !decoration.drawsBlank()) g.space_slot else ensureGlyph(g, cp, role, decoration),
+ .slot = cellSlot(g, line, at, cursor, role),
.fg = fg,
.bg = bg,
.role = role,
@@ -5356,10 +6714,11 @@ fn cellFontRole(cell: *const pardes.Cell) pardes.FontRole {
test "concealed terminal text emits no ink on opaque or transparent ground" {
var g: Gui = undefined;
g.space_slot = .{ .u = 0, .v = 0 };
+ g.words = .{};
var cell: pardes.Cell = .{ .default = false, .style = .{ .invisible = true, .ul = .single } };
cell.text[0] = 'X';
for ([_]Ground{ .opaqueRgb(bg_default), .{ .rgb = bg_default, .clear = true } }) |page| {
- const resolved = resolveCell(&g, &cell, .body, false, page);
+ const resolved = resolveCell(&g, (&cell)[0..1], 0, null, .body, false, page);
try std.testing.expectEqualDeep(g.space_slot, resolved.slot);
try std.testing.expectEqual(page.rgb, resolved.bg);
}
@@ -5369,74 +6728,153 @@ fn cellInstanceCount(cell: *const pardes.Cell) u32 {
return if (cellFontRole(cell) == .tagline) 2 else 1;
}
-fn taglineBaseRgb(core: *const pardes.Pardes, col: u16, row: u16) [3]u8 {
- const chrome = core.chromeTheme();
- if (!core.settings.focus_tint) return chrome.tag_bg;
- if (row >= pardes.TOPBAR_H and row < pardes.TOPBAR_H + core.columnBarHeight()) {
- for (0..core.ncol) |column| for (core.col_panes[column][0..core.col_n[column]]) |id| {
- if (id != core.active) continue;
- const x = core.col_x[column];
- if (col >= x and col - x < core.col_w[column]) return chrome.tag_active_bg;
- };
+fn tagLayerIn(layers: []const pardes.Layer, col: u16, row: u16) ?*const pardes.Layer {
+ for (layers) |*layer| {
+ const r = layer.viewport;
+ if (layer.rows > 0 and row >= r.y and row - r.y < layer.rows and col >= r.x and col - r.x < r.w) return layer;
}
- const r = core.rects[core.active];
- const tag_y = if (core.settings.tag_bottom) r.y + r.h -| pardes.BOX_H else r.y;
- return if (r.h > 0 and row == tag_y and col >= r.x and col - r.x < r.w) chrome.tag_active_bg else chrome.tag_bg;
+ return null;
+}
+
+fn expectCoverIsScan(cover: []const Cover, cols: u16, rows: u16, body_layers: []const pardes.Layer, tag_layers: []const pardes.Layer) !void {
+ for (0..rows) |row| for (0..cols) |col| {
+ const scan = bodyLayerIn(body_layers, @intCast(col), @intCast(row)) != null or tagLayerIn(tag_layers, @intCast(col), @intCast(row)) != null;
+ try std.testing.expectEqual(scan, cover[row * cols + col].layer);
+ };
}
-test "compact column and pane underlays share focus tint without tinting the global tag" {
- const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 120, .rows = 24 });
+test "the layer cover is the per-cell layer scan, over a core's layouts and random layers" {
+ // A gui-shaped core: its tagline is narrower and shorter than the body,
+ // so tags and notices are layers.
+ const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 97, .rows = 31 });
defer core.deinit();
- _ = try core.newShell(1, "");
+ core.update(.{ .resize = .{ .cols = 97, .rows = 31, .row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 7, .tagline_h = 13 } } });
+ for (1..4) |id| _ = try core.newShell(id, "");
try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
- pardes.test_api.sync(core);
- core.active = 1;
- const active = core.rects[1];
- const inactive = core.rects[0];
- const chrome = core.chromeTheme();
- try std.testing.expectEqual(chrome.tag_bg, taglineBaseRgb(core, active.x, 0));
- try std.testing.expectEqual(chrome.tag_active_bg, taglineBaseRgb(core, active.x, pardes.TOPBAR_H));
- try std.testing.expectEqual(chrome.tag_bg, taglineBaseRgb(core, inactive.x, pardes.TOPBAR_H));
- try std.testing.expectEqual(chrome.tag_active_bg, taglineBaseRgb(core, active.x, active.y));
- core.settings.focus_tint = false;
- try std.testing.expectEqual(chrome.tag_bg, taglineBaseRgb(core, active.x, pardes.TOPBAR_H));
+ pardes.layout.insert(core, 1, 1, 2);
+ pardes.layout.insert(core, 0, 1, 3);
+ var cover: [97 * 31]Cover = undefined;
+ var notices = false;
+ for (0..32) |step| {
+ core.settings.tag_bottom = step & 1 != 0;
+ if (step & 3 == 0) try std.testing.expect(core.executeBuiltinLine(2, "Collapse"));
+ core.leader_on = step & 4 != 0;
+ if (step & 8 != 0) {
+ try std.testing.expect(core.executeBuiltinLine(0, "Msg a message chip over the body"));
+ try std.testing.expect(core.executeBuiltinLine(3, "Msg another"));
+ }
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expectEqual(@as(usize, cover.len), @as(usize, s.cols) * s.rows);
+ @memset(&cover, .{ .layer = true, .floating = true, .grip = true, .focus = true }); // what an earlier frame left
+ coverFrame(&cover, s.cols, s.rows, s.bodyLayers(), s.tagLayers(), s.regionList());
+ try expectCoverIsScan(&cover, s.cols, s.rows, s.bodyLayers(), s.tagLayers());
+ // A grip's cells know their way to its glyph, and the focused
+ // pane's tag rows are the focused ones.
+ for (s.regionList()) |region| {
+ if (region.kind != .grip) continue;
+ for (0..region.rect.w) |offset| {
+ const cell = cover[@as(usize, region.rect.y) * s.cols + region.rect.x + offset];
+ try std.testing.expect(cell.grip);
+ try std.testing.expectEqual(offset, cell.grip_offset);
+ try std.testing.expectEqual(region.owner == core.active, cell.focus);
+ }
+ }
+ for (s.tagLayers()) |layer| notices = notices or (layer.rows != 0 and layer.kind == .notice);
+ }
+ try std.testing.expect(notices);
+
+ // Random layers: overlapping, empty, past the grid's right and bottom
+ // edges, and at the top of u16, where x + w overflows it.
+ const gen = struct {
+ fn coordinate(random: std.Random, limit: u16) u16 {
+ if (random.uintLessThan(u8, 12) == 0) return std.math.maxInt(u16) - random.uintLessThan(u16, 3);
+ return random.uintAtMost(u16, limit + 3);
+ }
+ fn rect(random: std.Random, cols: u16, rows: u16) pardes.Rect {
+ return .{ .x = coordinate(random, cols), .y = coordinate(random, rows), .w = coordinate(random, cols), .h = coordinate(random, rows / 2) };
+ }
+ };
+ var prng = std.Random.DefaultPrng.init(0x6c61796572);
+ const random = prng.random();
+ var body: [pardes.MAX_PANES]pardes.Layer = undefined;
+ var tag: [pardes.MAX_TAG_LAYERS]pardes.Layer = undefined;
+ var grid: [64 * 40]Cover = undefined;
+ for (0..3000) |_| {
+ const cols = random.intRangeAtMost(u16, 1, 64);
+ const rows = random.intRangeAtMost(u16, 1, 40);
+ const empty = random.intRangeAtMost(u8, 2, 5); // about one layer in `empty` is empty
+ for (&body) |*layer| layer.* = .{ .rows = @intFromBool(random.uintLessThan(u8, empty) != 0), .viewport = gen.rect(random, cols, rows) };
+ for (&tag) |*layer| layer.* = .{ .rows = @intFromBool(random.uintLessThan(u8, empty) != 0), .viewport = gen.rect(random, cols, rows) };
+ const bodies = body[0..random.uintAtMost(usize, body.len)];
+ const tags = tag[0..random.uintAtMost(usize, tag.len)];
+ const cells = grid[0 .. @as(usize, cols) * rows];
+ @memset(cells, .{ .layer = random.boolean() });
+ coverFrame(cells, cols, rows, bodies, tags, &.{});
+ try expectCoverIsScan(cells, cols, rows, bodies, tags);
+ }
}
-fn tagLayerIn(layers: []const pardes.TagLayer, col: u16, row: u16) ?*const pardes.TagLayer {
- for (layers) |*layer| {
- const r = layer.viewport;
- if (layer.cols > 0 and row == r.y and col >= r.x and col - r.x < r.w) return layer;
+/// The bottom of pane `owner`'s body, in window pixels.
+fn bodyBottom(surface: *const pardes.Surface, owner: u16, layout: CellLayout) ?f32 {
+ for (surface.regionList()) |region| {
+ if (region.kind == .body and region.owner == owner) return @as(f32, @floatFromInt(region.rect.y + region.rect.h)) * layout.h;
}
return null;
}
-fn tagLayerCellCount(g: *const Gui, layer: *const pardes.TagLayer) u32 {
+fn tagLayerCellCount(g: *const Gui, layer: *const pardes.Layer) u32 {
const pixels = @as(u32, layer.viewport.w) * g.cell_w;
return @min(layer.cols, (pixels + g.tagline_width - 1) / g.tagline_width);
}
-fn emitTagLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const pardes.TagLayer, win_w: f32, win_h: f32, track: ?pardes.layout.Track, page: Ground, show_cursor: bool, old_layer: bool) void {
+fn emitTagLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const pardes.Layer, win_w: f32, win_h: f32, track: ?pardes.animation.Track, page: Ground, show_cursor: bool, old_layer: bool) void {
const bw: f32 = @floatFromInt(g.cell_w);
const bh: f32 = @floatFromInt(g.cell_h);
const tw: f32 = @floatFromInt(g.tagline_width);
const left = @as(f32, @floatFromInt(layer.viewport.x)) * bw;
const right = left + @as(f32, @floatFromInt(layer.viewport.w)) * bw;
const background: pardes.Cell = .{ .default = false, .style = .{ .bg = .{ .rgb = layer.bg } } };
- emitInstance(g, instances, next.*, 0, layer.viewport.y, .{ .w = right - left, .h = bh, .x_off = left, .y_off = 0 }, win_w, win_h, track, .body, &background, old_layer, false, page);
- next.* += 1;
- for (0..tagLayerCellCount(g, layer)) |col| {
- const cursor = if (layer.cursor) |cu| show_cursor and !cu.bar and cu.col == col else false;
- emitInstance(g, instances, next.*, @intCast(col), layer.viewport.y, .{ .w = tw, .h = bh, .x_off = left, .y_off = 0 }, win_w, win_h, track, .tagline, &layer.cells[col], old_layer, cursor, page);
- clipInstanceRight(&instances[next.*], right, win_w);
+ // A band sliding into place is drawn offset and cut at its row's top, so
+ // it comes out from under whatever is above it.
+ const slide = layer.slide * bh;
+ // A window is rarely a whole number of cells wide: a band that ends at
+ // the last column runs on through the leftover pixels to the edge.
+ const band_right = if (win_w - right < bw) @max(right, win_w) else right;
+ // A row to each line, each a grid row with the tagline's glyphs.
+ for (0..layer.rows) |index| {
+ const y = layer.viewport.y + @as(u16, @intCast(index));
+ const top = @as(f32, @floatFromInt(y)) * bh;
+ emitInstance(g, instances, next.*, 0, y, .{ .w = band_right - left, .h = bh, .x_off = left, .y_off = slide }, win_w, win_h, track, .body, (&background)[0..1], 0, null, old_layer, false, page);
+ // A theme's plaque is drawn under the band: the band's own ground
+ // lets it show (tagPlaques).
+ if (cell_decor.nplaques != 0 and cell_decor.inPlaque(left + 0.5, top + 0.5)) plaqueThrough(instances, next.*);
+ if (slide != 0) clipInstanceTop(&instances[next.*], top, win_h);
next.* += 1;
+ const cells = layer.cells[index * layer.cols ..][0..layer.cols];
+ const line_cursor: ?usize = if (layer.cursor) |cu| (if (cu.y == index) cu.x else null) else null;
+ for (0..tagLayerCellCount(g, layer)) |col| {
+ const cursor = if (layer.cursor) |cu| show_cursor and !cu.bar and cu.x == col and cu.y == index else false;
+ emitInstance(g, instances, next.*, @intCast(col), y, .{ .w = tw, .h = bh, .x_off = left, .y_off = slide }, win_w, win_h, track, .tagline, cells, col, line_cursor, old_layer, cursor, page);
+ clipInstanceRight(&instances[next.*], right, win_w);
+ if (slide != 0) clipInstanceTop(&instances[next.*], top, win_h);
+ next.* += 1;
+ }
}
}
-fn bodyLayerAt(surface: *const pardes.Surface, col: u16, row: u16) ?*const pardes.BodyLayer {
+fn clipInstanceTop(instance: *CellInstance, top: f32, win_h: f32) void {
+ const limit = 1 - top / win_h * 2;
+ if (instance.y0 <= limit) return;
+ const fraction = std.math.clamp((limit - instance.y1) / (instance.y0 - instance.y1), 0, 1);
+ instance.v0 = instance.v1 + (instance.v0 - instance.v1) * fraction;
+ instance.y0 = @max(instance.y1, limit);
+}
+
+fn bodyLayerAt(surface: *const pardes.Surface, col: u16, row: u16) ?*const pardes.Layer {
return bodyLayerIn(surface.bodyLayers(), col, row);
}
-fn bodyLayerIn(layers: []const pardes.BodyLayer, col: u16, row: u16) ?*const pardes.BodyLayer {
+fn bodyLayerIn(layers: []const pardes.Layer, col: u16, row: u16) ?*const pardes.Layer {
for (layers) |*layer| {
const r = layer.viewport;
if (layer.rows > 0 and col >= r.x and col - r.x < r.w and row >= r.y and row - r.y < r.h) return layer;
@@ -5460,7 +6898,7 @@ fn clipBodyInstance(instance: *CellInstance, bottom: f32, win_h: f32) void {
instance.y1 = limit;
}
-fn emitBodyLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const pardes.BodyLayer, win_w: f32, win_h: f32, track: ?pardes.layout.Track, page: Ground, show_cursor: bool, old_layer: bool, border_rgb: [3]u8) void {
+fn emitBodyLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const pardes.Layer, win_w: f32, win_h: f32, track: ?pardes.animation.Track, page: Ground, show_cursor: bool, old_layer: bool, border_rgb: [3]u8) void {
const bw: f32 = @floatFromInt(g.cell_w);
const bh: f32 = @floatFromInt(g.cell_h);
const tw: f32 = @floatFromInt(g.tagline_width);
@@ -5479,17 +6917,18 @@ fn emitBodyLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const
if (header) {
var background: pardes.Cell = .{ .default = false, .style = layer.cells[index * layer.cols].style };
background.style.font_role = .body;
- emitInstance(g, instances, next.*, 0, 0, .{ .w = @as(f32, @floatFromInt(layer.viewport.w)) * bw, .h = height, .x_off = left, .y_off = top }, win_w, win_h, track, .body, &background, old_layer, false, page);
+ emitInstance(g, instances, next.*, 0, 0, .{ .w = @as(f32, @floatFromInt(layer.viewport.w)) * bw, .h = height, .x_off = left, .y_off = top }, win_w, win_h, track, .body, (&background)[0..1], 0, null, old_layer, false, page);
clipBodyInstance(&instances[next.*], bottom, win_h);
clipInstanceRight(&instances[next.*], right, win_w);
next.* += 1;
}
+ const line = layer.cells[index * layer.cols ..][0..layer.cols];
+ const line_cursor: ?usize = if (layer.cursor) |cu| if (cu.y == row) cu.x else null else null;
for (0..layer.cols) |col| {
if (left + @as(f32, @floatFromInt(col)) * width >= right) break;
- const cell = &layer.cells[index * layer.cols + col];
const cursor = if (layer.cursor) |cu| show_cursor and !cu.bar and cu.x == col and cu.y == row else false;
- const glyph_top = top - (if (header) @as(f32, @floatFromInt(taglineBandOffset(0, win_h, g.cell_h, g.tagline_height, true))) else 0);
- emitInstance(g, instances, next.*, 0, 0, .{ .w = width, .h = height, .x_off = left + @as(f32, @floatFromInt(col)) * width, .y_off = glyph_top }, win_w, win_h, track, role, cell, old_layer, cursor, page);
+ const glyph_top = top - (if (header) @as(f32, @floatFromInt(taglineBandOffset(0, win_h, g.cell_h, g.tagline_height))) else 0);
+ emitInstance(g, instances, next.*, 0, 0, .{ .w = width, .h = height, .x_off = left + @as(f32, @floatFromInt(col)) * width, .y_off = glyph_top }, win_w, win_h, track, role, line, col, line_cursor, old_layer, cursor, page);
clipBodyInstance(&instances[next.*], bottom, win_h);
clipInstanceRight(&instances[next.*], right, win_w);
next.* += 1;
@@ -5501,7 +6940,7 @@ fn emitBodyLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const
.h = 1,
.x_off = left,
.y_off = top + height - 1,
- }, win_w, win_h, track, .body, &border, old_layer, false, page);
+ }, win_w, win_h, track, .body, (&border)[0..1], 0, null, old_layer, false, page);
clipBodyInstance(&instances[next.*], bottom, win_h);
clipInstanceRight(&instances[next.*], right, win_w);
next.* += 1;
@@ -5509,38 +6948,84 @@ fn emitBodyLayer(g: *Gui, instances: [*]CellInstance, next: *u32, layer: *const
}
}
-const GripCell = struct { cell: *const pardes.Cell, offset: u16 };
-
-fn gripCellChanged(surface: *const pardes.Surface, col: u16, row: u16) bool {
+/// A dissolving cell changes with its grip's glyph, which is the cell its
+/// grip offset to the left, in this frame's grip or the last one's.
+fn gripCellChanged(surface: *const pardes.Surface, covered: []const Cover, previous_covered: []const Cover, col: u16, row: u16) bool {
if (surface.panelCellChanged(col, row)) return true;
- if (paneGripCell(surface.tagLayers(), surface.cells, surface.cols, col, row)) |grip| {
- if (surface.panelCellChanged(col - grip.offset, row)) return true;
- }
- if (paneGripCell(surface.previous_tag_layers, surface.previous_cells, surface.cols, col, row)) |grip| {
- if (surface.panelCellChanged(col - grip.offset, row)) return true;
- }
+ const at = @as(usize, row) * surface.cols + col;
+ for ([_]Cover{ covered[at], previous_covered[at] }) |cover|
+ if (cover.grip and surface.panelCellChanged(col -| cover.grip_offset, row)) return true;
return false;
}
-fn paneGripCell(layers: []const pardes.TagLayer, cells: []const pardes.Cell, cols: u16, col: u16, row: u16) ?GripCell {
- const at = @as(usize, row) * cols + col;
- if (at >= cells.len or cells[at].default or cells[at].style.font_role != .tagline) return null;
- for (layers) |layer| {
- if (layer.cols == 0 or layer.kind != .pane or layer.viewport.x < pardes.TAG_TEXT_INSET or layer.viewport.y != row) continue;
- const x = layer.viewport.x - pardes.TAG_TEXT_INSET;
- if (col < x or col - x >= config.GUTTER) continue;
- const index = @as(usize, row) * cols + x;
- if (index >= cells.len) return null;
- const cell = &cells[index];
- if (cell.default or cell.printableAscii() == ' ' or cell.style.invisible) return null;
- return .{ .cell = cell, .offset = col - x };
+fn anchorInset(g: *const Gui, row: u16, win_h: f32) u32 {
+ return taglineBandOffset(row, win_h, g.cell_h, g.tagline_height);
+}
+
+/// acme's Scrollwid column at a pane's or column's left edge, in window
+/// pixels: where its button sits over its scrollbar, one width for both
+/// (`rail_px` at acme's 17px font, scaled with the tagline, and always
+/// short of the cell so the text keeps a gap), right of the column's rule.
+fn scrollColumn(g: *const Gui, chrome: *const pardes.Chrome, col: u16, layout: CellLayout) [2]f32 {
+ const rule: f32 = if (col == 0) 0 else rulePx(chrome);
+ const x0 = @round(@as(f32, @floatFromInt(col)) * layout.w + rule);
+ const scaled: f32 = @round(@as(f32, @floatFromInt(@max(1, chrome.rail_px))) * @as(f32, @floatFromInt(g.tagline_height)) / 17);
+ // The rail and the grip are GUTTER cells wide; the text starts after.
+ const w = std.math.clamp(scaled, dp(4), @max(dp(4), @floor(layout.w * @as(f32, @floatFromInt(config.GUTTER))) - rule - dp(3)));
+ return .{ x0, x0 + w };
+}
+
+/// acme's button for the grip whose first cell is (col, row), in window
+/// pixels: the scroll column wide, its tag row tall, from the rule above to
+/// the rule below, so button and scrollbar read as one strip.
+fn gripButton(g: *const Gui, chrome: *const pardes.Chrome, col: u16, row: u16, layout: CellLayout, win_h: f32) [4]f32 {
+ _ = win_h;
+ const x = scrollColumn(g, chrome, col, layout);
+ const y0 = @round(@as(f32, @floatFromInt(row)) * layout.h);
+ return .{ x[0], y0, x[1], @round(@as(f32, @floatFromInt(row + 1)) * layout.h) };
+}
+
+/// A pane's button fill, from its region's state, not the grid's cells
+/// (which are drawn for cell shells): dirty, focused, or the tag's ground.
+fn gripFill(chrome: *const pardes.Chrome, focus: bool, dirty: bool) [3]u8 {
+ if (dirty) return chrome.grip_dirty;
+ return if (focus) chrome.grip_focus_ring else chrome.tag_bg;
+}
+
+fn inkOn(bg: [3]u8) [3]u8 {
+ const lum = (@as(u16, bg[0]) * 3 + @as(u16, bg[1]) * 6 + @as(u16, bg[2])) / 10;
+ return if (lum > 140) .{ 0x00, 0x00, 0x00 } else .{ 0xff, 0xff, 0xff };
+}
+
+/// Cuts an instance's quad to a pixel rectangle, its atlas window with it so
+/// the glyph neither moves nor stretches; nothing left, an empty quad.
+fn clipInstance(instance: *CellInstance, r: [4]f32, win_w: f32, win_h: f32) void {
+ const x0 = (instance.x0 + 1) / 2 * win_w;
+ const x1 = (instance.x1 + 1) / 2 * win_w;
+ const y0 = (1 - instance.y0) / 2 * win_h;
+ const y1 = (1 - instance.y1) / 2 * win_h;
+ const left = @max(0, r[0] - x0);
+ const right = @max(0, x1 - r[2]);
+ const top = @max(0, r[1] - y0);
+ const bottom = @max(0, y1 - r[3]);
+ if (x1 - right <= x0 + left or y1 - bottom <= y0 + top) {
+ instance.x1 = instance.x0;
+ instance.y1 = instance.y0;
+ return;
}
- return null;
+ instance.x0 += left / win_w * 2;
+ instance.u0 += left / atlas_w;
+ instance.x1 -= right / win_w * 2;
+ instance.u1 -= right / atlas_w;
+ instance.y0 -= top / win_h * 2;
+ instance.v0 += top / atlas_h;
+ instance.y1 += bottom / win_h * 2;
+ instance.v1 -= bottom / atlas_h;
}
fn emitSurfaceCell(
g: *Gui,
- core: ?*const pardes.Pardes,
+ chrome: *const pardes.Chrome,
instances: [*]CellInstance,
next: *u32,
col: u16,
@@ -5548,49 +7033,247 @@ fn emitSurfaceCell(
body_layout: CellLayout,
win_w: f32,
win_h: f32,
- track: ?pardes.layout.Track,
- cell: *const pardes.Cell,
- tagline_base: *const pardes.Cell,
- grip: ?GripCell,
+ track: ?pardes.animation.Track,
+ line: []const pardes.Cell,
+ line_cover: []const Cover,
+ at: usize,
+ cursor: ?usize,
old_layer: bool,
is_cursor: bool,
page: Ground,
) void {
- const role = cellFontRole(cell);
+ const role = cellFontRole(&line[at]);
if (role == .tagline) {
- var band_base = tagline_base.*;
- if (core) |p| band_base.style.bg = .{ .rgb = taglineBaseRgb(p, col, row) };
+ const here = line_cover[at];
+ const band_base: pardes.Cell = .{
+ .style = .{ .bg = .{ .rgb = if (here.focus) chrome.tag_focus_bg else chrome.tag_bg }, .font_role = .tagline },
+ .default = false,
+ };
// The smaller font changes the ink, not the chrome's coverage. Painting
// this underlay at tagline height leaves page-colored gutters between
// adjacent workspace, column and pane tags at TaglineSize < 100.
- emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, .body, &band_base, old_layer, false, page);
+ emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, .body, (&band_base)[0..1], 0, null, old_layer, false, page);
+ // Over a theme's plaque the underlay lets it show (tagPlaques),
+ // in a grip's cell too where the plaque reaches into it past the
+ // button (which is drawn over the cells).
+ const cell_x = @as(f32, @floatFromInt(col)) * body_layout.w + body_layout.x_off;
+ const cell_y = @as(f32, @floatFromInt(row)) * body_layout.h + body_layout.y_off + 0.5;
+ if (cell_decor.nplaques != 0 and cell_decor.inPlaque(if (here.grip) cell_x + body_layout.w - 0.5 else cell_x + 0.5, cell_y))
+ plaqueThrough(instances, next.*);
next.* += 1;
// Tag glyphs keep their font size inside a full physical-width grip.
- emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, .tagline, cell, old_layer, is_cursor, page);
- if (grip) |indicator| {
- const cached = cachedGlyph(g, cellCodepoint(indicator.cell), .tagline, GlyphDecoration.fromCell(indicator.cell), true);
+ // A pane's grip cells are the cell shells' form (a dirty `*`): the
+ // button draws its own glyph over a blank of them.
+ var blank = line[at];
+ blank.text[0] = ' ';
+ blank.len = 1;
+ if (here.pane_grip)
+ emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, .tagline, (&blank)[0..1], 0, null, old_layer, false, page)
+ else
+ emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, .tagline, line, at, cursor, old_layer, is_cursor, page);
+ // A grip's glyph is the cell at its left edge, and a blank one is
+ // no glyph: its marks are decor.
+ const glyph = &line[at - @min(here.grip_offset, at)];
+ const grip = here.grip and here.grip_top and !glyph.default and glyph.printableAscii() != ' ' and !glyph.style.invisible;
+ const offset: u16 = if (grip) @min(here.grip_offset, at) else 0;
+ // An anchor starts at its column's rule: its left edge is inset by
+ // its top margin so the band frames it on the left as above and
+ // below, and its mark moves right by half that to stay centered.
+ const inset: u32 = if (line_cover[at - offset].anchor) anchorInset(g, row, win_h) else 0;
+ // A grip is acme's button: its fill is this cell's ground, cut to
+ // the button (and a dirty one's inset a pixel inside its ring, so
+ // the ring reads round it), its glyph centered in it.
+ const button = if (here.grip and here.grip_top) gripButton(g, chrome, col - @min(here.grip_offset, @as(u16, @intCast(at))), row, body_layout, win_h) else null;
+ if (grip) {
+ // A grip is one glyph centered across the gutter, not text: it is
+ // looked up by its codepoint's glyph, never shaped.
+ const drawn = glyphForCodepoint(g, cellCodepoint(glyph));
+ const cached = cachedGlyph(g, .{ .face = drawn.face, .glyph = drawn.glyph, .role = .tagline, .decoration = GlyphDecoration.fromCell(glyph), .centered = true });
const slot = cached orelse g.space_slot;
- const offset: u32 = if (cached != null) @as(u32, indicator.offset) * g.cell_w else 0;
- const resolved = resolveCell(g, indicator.cell, .tagline, false, page);
- instances[next.*].fr = @as(f32, @floatFromInt(resolved.fg[0])) / 255;
- instances[next.*].fg = @as(f32, @floatFromInt(resolved.fg[1])) / 255;
- instances[next.*].fb = @as(f32, @floatFromInt(resolved.fg[2])) / 255;
- instances[next.*].u0 = @as(f32, @floatFromInt(slot.u + offset)) / atlas_w;
+ const b = button.?;
+ const center = (b[0] + b[2]) / 2 - @as(f32, @floatFromInt(col - offset)) * body_layout.w;
+ const shift: f32 = if (cached != null) @as(f32, @floatFromInt(@as(u32, offset) * g.cell_w)) + @as(f32, @floatFromInt(config.GUTTER * g.cell_w)) / 2 - center else 0;
+ const resolved = resolveCell(g, glyph[0..1], 0, null, .tagline, false, page);
+ const ink = if (here.pane_grip) inkOn(gripFill(chrome, here.focus, here.dirty)) else resolved.fg;
+ instances[next.*].fr = @as(f32, @floatFromInt(ink[0])) / 255;
+ instances[next.*].fg = @as(f32, @floatFromInt(ink[1])) / 255;
+ instances[next.*].fb = @as(f32, @floatFromInt(ink[2])) / 255;
+ instances[next.*].u0 = (@as(f32, @floatFromInt(slot.u)) + shift) / atlas_w;
instances[next.*].v0 = @as(f32, @floatFromInt(slot.v)) / atlas_h;
instances[next.*].v1 = @as(f32, @floatFromInt(slot.v + g.tagline_height)) / atlas_h;
}
instances[next.*].u1 = instances[next.*].u0 + @as(f32, @floatFromInt(g.cell_w)) / atlas_w;
+ if (button) |b| {
+ // acme's button fills its tag row from the rule above to the rule
+ // below: the underlay is its fill, cut to its columns; a pane's
+ // from its region's state, not the grid's cell form (whose dirty
+ // `*` is the cell shells'), a column's its cell's own ground.
+ const base = &instances[next.* - 1];
+ const own: [3]f32 = .{ instances[next.*].br, instances[next.*].bg, instances[next.*].bb };
+ if (here.pane_grip) {
+ const fill = gripFill(chrome, here.focus, here.dirty);
+ base.br = @as(f32, @floatFromInt(fill[0])) / 255;
+ base.bg = @as(f32, @floatFromInt(fill[1])) / 255;
+ base.bb = @as(f32, @floatFromInt(fill[2])) / 255;
+ } else {
+ base.br = own[0];
+ base.bg = own[1];
+ base.bb = own[2];
+ }
+ base.effect &= ~clear_bg_bit;
+ clipInstance(base, .{ b[0], -1e9, b[2], 1e9 }, win_w, win_h);
+ // Over it, only its own glyph; the band round it and the ring
+ // are decor (gripDecor).
+ if (here.pane_grip and !grip) {
+ instances[next.*].u0 = @as(f32, @floatFromInt(g.space_slot.u)) / atlas_w;
+ instances[next.*].u1 = instances[next.*].u0 + @as(f32, @floatFromInt(g.cell_w)) / atlas_w;
+ instances[next.*].v0 = @as(f32, @floatFromInt(g.space_slot.v)) / atlas_h;
+ instances[next.*].v1 = @as(f32, @floatFromInt(g.space_slot.v + g.tagline_height)) / atlas_h;
+ }
+ // Its ground is the fill again (a see-through ground would be
+ // written, not blended, in an opaque window).
+ instances[next.*].br = base.br;
+ instances[next.*].bg = base.bg;
+ instances[next.*].bb = base.bb;
+ instances[next.*].effect &= ~clear_bg_bit;
+ clipInstance(&instances[next.*], b, win_w, win_h);
+ } else if (inset > 0) {
+ instances[next.*].x0 += @as(f32, @floatFromInt(inset)) / win_w * 2;
+ instances[next.*].u0 += @as(f32, @floatFromInt(inset)) / atlas_w;
+ }
next.* += 1;
return;
}
- emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, role, cell, old_layer, is_cursor, page);
+ emitInstance(g, instances, next.*, col, row, body_layout, win_w, win_h, track, role, line, at, cursor, old_layer, is_cursor, page);
next.* += 1;
}
-test "small tagline fonts leave no background gutters between adjacent tags" {
- const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
+test "every pixel of a grip column is band, button or ring, and the button sits over the scrollbar" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 60, .rows = 20 });
defer core.deinit();
+ const pane = try core.setTestFile(std.mem.asBytes(&@as([60][5]u8, @splat("text\n".*))));
+ pane.tag.own = try gpa.dupe(u8, "second\nthird");
+ core.newScratchBelow(0);
+ for ([_]struct { w: u32, h: u32, tag: u32 }{ .{ .w = 10, .h = 20, .tag = 12 }, .{ .w = 17, .h = 35, .tag = 30 }, .{ .w = 9, .h = 19, .tag = 15 }, .{ .w = 12, .h = 24, .tag = 24 } }) |m| for ([_]bool{ false, true }) |bottom| for ([_]usize{ 0, 1 }) |focus| for ([_]bool{ false, true }) |dirty| {
+ core.settings.tag_bottom = bottom;
+ core.active = focus;
+ pane.file.?.revision = pane.file.?.saved_revision + @intFromBool(dirty);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ var g: Gui = undefined;
+ g.words = .{};
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = m.w;
+ g.cell_h = m.h;
+ g.tagline_width = m.w;
+ g.tagline_height = m.tag;
+ g.space_slot = .{ .u = 0, .v = 0 };
+ const layout = fixedCellLayout(&g);
+ const win_w: f32 = @floatFromInt(60 * m.w);
+ const win_h: f32 = @floatFromInt(20 * m.h);
+ const cover = try gpa.alloc(Cover, @as(usize, s.cols) * s.rows);
+ defer gpa.free(cover);
+ coverFrame(cover, s.cols, s.rows, s.bodyLayers(), s.tagLayers(), s.regionList());
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, layout, win_w, win_h, true);
+ const grip = s.region(.grip, 0).?;
+ // The grip column's pixels, band first, then its cells, then decor.
+ const x_px: u32 = grip.rect.x * m.w;
+ const w_px: u32 = config.GUTTER * m.w;
+ const y_px: u32 = grip.rect.y * m.h;
+ const h_px: u32 = grip.rect.h * m.h;
+ const pixels = try gpa.alloc(?[3]f32, w_px * h_px);
+ defer gpa.free(pixels);
+ @memset(pixels, null);
+ const paint = struct {
+ fn quad(into: []?[3]f32, x0n: f32, y0n: f32, x1n: f32, y1n: f32, rgb: [3]f32, ww: f32, wh: f32, ox: u32, oy: u32, pw: u32, ph: u32) void {
+ const px0: i64 = @intFromFloat(@round((x0n + 1) / 2 * ww));
+ const px1: i64 = @intFromFloat(@round((x1n + 1) / 2 * ww));
+ const py0: i64 = @intFromFloat(@round((1 - y0n) / 2 * wh));
+ const py1: i64 = @intFromFloat(@round((1 - y1n) / 2 * wh));
+ var y = @max(py0, oy);
+ while (y < @min(py1, oy + ph)) : (y += 1) {
+ var x = @max(px0, ox);
+ while (x < @min(px1, ox + pw)) : (x += 1) into[@intCast((y - oy) * pw + (x - ox))] = rgb;
+ }
+ }
+ };
+ var instances: [4]CellInstance = undefined;
+ for (0..grip.rect.h) |line| for (0..config.GUTTER) |dx| {
+ const col: u16 = grip.rect.x + @as(u16, @intCast(dx));
+ const row: u16 = grip.rect.y + @as(u16, @intCast(line));
+ const at = @as(usize, row) * s.cols;
+ var next: u32 = 0;
+ emitSurfaceCell(&g, &s.chrome, &instances, &next, col, row, layout, win_w, win_h, null, s.cells[at..][0..s.cols], cover[at..][0..s.cols], col, null, false, false, Ground.opaqueRgb(bg_default));
+ for (instances[0..next]) |i| paint.quad(pixels, i.x0, i.y0, i.x1, i.y1, .{ i.br, i.bg, i.bb }, win_w, win_h, x_px, y_px, w_px, h_px);
+ };
+ for (g.decor.items) |i| if (i.fr >= 1 and i.clip_x1 < i.clip_x0) paint.quad(pixels, i.x0, i.y0, i.x1, i.y1, .{ i.br, i.bg, i.bb }, win_w, win_h, x_px, y_px, w_px, h_px);
+ const rgb = struct {
+ fn of(v: [3]u8) [3]f32 {
+ return .{ @as(f32, @floatFromInt(v[0])) / 255, @as(f32, @floatFromInt(v[1])) / 255, @as(f32, @floatFromInt(v[2])) / 255 };
+ }
+ }.of;
+ const chrome = &s.chrome;
+ const band = if (focus == 0) chrome.tag_focus_bg else chrome.tag_bg;
+ // Band, fills, rings, the rules between stacked panes and under the
+ // tag, and the mode marks' ink (the grip's first cell's).
+ const ink = inkOn(gripFill(chrome, grip.active, grip.dirty));
+ const allowed = [_][3]f32{ rgb(band), rgb(core.chromeTheme().box), rgb(pardes.draw.boxDirty(core)), rgb(chrome.grip_border), rgb(chrome.grip_focus_ring), rgb(chrome.border), rgb(ink), rgb(chrome.tag_rule orelse mixRgb(chrome.tag_bg, chrome.page orelse bg_default)) };
+ for (pixels, 0..) |pixel, n| {
+ const got = pixel orelse return error.TestUnpaintedGripPixel;
+ const known = for (allowed) |a| {
+ if (std.meta.eql(a, got)) break true;
+ } else false;
+ // Under the first row there is no button: band and rules only.
+ if (n / w_px >= m.h and n / w_px < h_px - 1 and !std.meta.eql(got, rgb(band)) and !std.meta.eql(got, rgb(chrome.border)))
+ return error.TestButtonUnderFirstRow;
+ if (!known) std.debug.print("sliver {any} at {d},{d} of {d}x{d} (metrics {d}x{d}/{d}, bottom {}, focus {d}, dirty {}) page {any}\n", .{ got, n % w_px, n / w_px, w_px, h_px, m.w, m.h, m.tag, bottom, focus, dirty, s.chrome.page });
+ try std.testing.expect(known);
+ }
+ // The rule under the tag runs unbroken across the grip column.
+ if (!bottom) for (pixels[(h_px - 1) * w_px ..][0..w_px]) |pixel|
+ try std.testing.expectEqual(rgb(chrome.tag_rule orelse mixRgb(chrome.tag_bg, chrome.page orelse bg_default)), pixel.?);
+ // The button's edges are the scrollbar's.
+ const button = gripButton(&g, chrome, grip.rect.x, grip.rect.y, layout, win_h);
+ const column = scrollColumn(&g, chrome, s.region(.rail, 0).?.rect.x, layout);
+ try std.testing.expectEqual(column[0], button[0]);
+ try std.testing.expectEqual(column[1], button[2]);
+ };
+ pane.file.?.revision = pane.file.?.saved_revision;
+}
+
+test "a rising pane past its mark stays inside its box" {
+ // Bouncy, a vertical rise at its highest overshoot: drawn past its box,
+ // clipped to it.
+ var g: Gui = undefined;
+ g.cell_w = 10;
+ g.cell_h = 20;
+ var track: pardes.animation.Track = .{ .serial = 3, .phase = .opening, .effect = .vertical, .motion = @backingInt(pardes.animation.Motion.Flavour.bouncy) + 1, .frame_count = 20, .from = .{ .x = 0, .y = 10, .w = 40, .h = 10 }, .to = .{ .x = 0, .y = 0, .w = 40, .h = 10 } };
+ var peak: u16 = 0;
+ var highest: f32 = 1e9;
+ while (track.frame < track.frames()) : (track.frame += 1) {
+ if (track.presented().y < highest) {
+ highest = track.presented().y;
+ peak = track.frame;
+ }
+ }
+ track.frame = peak;
+ try std.testing.expect(track.presented().y < 0);
+ var instance: CellInstance = std.mem.zeroes(CellInstance);
+ setTransitionFields(&instance, track, fixedCellLayout(&g), 800, 480, 0);
+ try std.testing.expectEqual(@as(f32, 0), instance.clip_y0);
+ try std.testing.expectEqual(@as(f32, 200), instance.clip_y1);
+}
+
+test "small tagline fonts leave no background gutters between adjacent tags" {
+ const chrome: pardes.Chrome = .{};
var g: Gui = undefined;
+ g.words = .{};
g.cell_w = 10;
g.cell_h = 20;
g.tagline_width = 8;
@@ -5600,7 +7283,8 @@ test "small tagline fonts leave no background gutters between adjacent tags" {
var instances: [6]CellInstance = undefined;
var next: u32 = 0;
for (0..3) |row| {
- emitSurfaceCell(&g, core, &instances, &next, 0, @intCast(row), fixedCellLayout(&g), 800, 480, null, &cell, &cell, null, false, false, Ground.opaqueRgb(bg_default));
+ // Column 1: past the anchor's inset edge at the column's left.
+ emitSurfaceCell(&g, &chrome, &instances, &next, 1, @intCast(row), fixedCellLayout(&g), 800, 480, null, (&cell)[0..1], &.{.{}}, 0, null, false, false, Ground.opaqueRgb(bg_default));
const base = instances[row * 2];
const ink = instances[row * 2 + 1];
try std.testing.expectApproxEqAbs(@as(f32, 20.0 / 480.0 * 2), base.y0 - base.y1, 0.0001);
@@ -5610,8 +7294,15 @@ test "small tagline fonts leave no background gutters between adjacent tags" {
try std.testing.expectApproxEqAbs(@as(f32, 10) / atlas_w, ink.u1 - ink.u0, 0.0001);
if (row > 0) try std.testing.expectApproxEqAbs(instances[(row - 1) * 2].y1, base.y0, 0.0001);
}
+ // Column 0 is an anchor's edge: its ink is inset by the band's margin
+ // (2 px here) and its underlay still covers the whole cell.
+ next = 0;
+ emitSurfaceCell(&g, &chrome, &instances, &next, 0, 1, fixedCellLayout(&g), 800, 480, null, (&cell)[0..1], &.{.{ .anchor = true }}, 0, null, false, false, Ground.opaqueRgb(bg_default));
+ try std.testing.expectApproxEqAbs(@as(f32, 10.0 / 800.0 * 2), instances[0].x1 - instances[0].x0, 0.0001);
+ try std.testing.expectApproxEqAbs(@as(f32, 8.0 / 800.0 * 2), instances[1].x1 - instances[1].x0, 0.0001);
+ try std.testing.expectApproxEqAbs(@as(f32, 8) / atlas_w, instances[1].u1 - instances[1].u0, 0.0001);
next = 0;
- emitSurfaceCell(&g, null, &instances, &next, 0, 2, fixedCellLayout(&g), 800, 480, null, &cell, &cell, null, true, false, Ground.opaqueRgb(bg_default));
+ emitSurfaceCell(&g, &chrome, &instances, &next, 0, 2, fixedCellLayout(&g), 800, 480, null, (&cell)[0..1], &.{.{}}, 0, null, true, false, Ground.opaqueRgb(bg_default));
try std.testing.expectEqual(@as(u32, 2), next);
try std.testing.expectApproxEqAbs(@as(f32, 16.0 / 480.0 * 2), instances[1].y0 - instances[1].y1, 0.0001);
}
@@ -5625,14 +7316,16 @@ fn emitInstance(
layout: CellLayout,
win_w: f32,
win_h: f32,
- track: ?pardes.layout.Track,
+ track: ?pardes.animation.Track,
role: pardes.FontRole,
- cell: *const pardes.Cell,
+ line: []const pardes.Cell,
+ at: usize,
+ cursor: ?usize,
old_layer: bool,
is_cursor: bool,
page: Ground,
) void {
- const resolved = resolveCell(g, cell, role, is_cursor, page);
+ const resolved = resolveCell(g, line, at, cursor, role, is_cursor, page);
const px0 = layout.x_off + @as(f32, @floatFromInt(col)) * layout.w;
const visual_h: f32 = if (resolved.role == .tagline)
@@ -5640,7 +7333,7 @@ fn emitInstance(
else
layout.h;
const band_offset: f32 = if (resolved.role == .tagline)
- @floatFromInt(taglineBandOffset(row, win_h, g.cell_h, g.tagline_height, true))
+ @floatFromInt(taglineBandOffset(row, win_h, g.cell_h, g.tagline_height))
else
0;
const py0 = layout.y_off + @as(f32, @floatFromInt(row)) * layout.h + band_offset;
@@ -5694,21 +7387,176 @@ fn emitInstance(
// A block cursor is foreground UI ink, even though its color is carried
// in the reversed cell background. Keep it visible at WindowOpacity 0.
if (is_cursor) instances[idx].effect |= opaque_bg_bit;
+ // The theme's ornament (cell_decor): dots on the page's own ground, a
+ // shadow under a file name's letters. Never on a cursor.
+ if (!is_cursor) {
+ // A blank cell on a tag's ground inside a plaque: the plaque shows.
+ if (cell_decor.nplaques != 0 and resolved.role == .tagline and cellCodepoint(&line[at]) == ' ' and
+ (std.mem.eql(u8, &resolved.bg, &cell_decor.grounds[0]) or std.mem.eql(u8, &resolved.bg, &cell_decor.grounds[1])) and
+ (cell_decor.inPlaque(px0 + 0.5, py0 + 0.5) or cell_decor.inPlaque(px0 + layout.w - 0.5, py0 + 0.5)))
+ plaqueThrough(instances, idx);
+ if (cell_decor.dots) |dotted| {
+ if (!resolved.clear_bg and std.mem.eql(u8, &resolved.bg, &dotted)) {
+ instances[idx].effect |= dotted_bit;
+ // G13: the dots under a body move with its text, a quarter
+ // as far; the serial slot carries it (the shader reads it
+ // as the dots' offset alone).
+ instances[idx].serial = @bitCast(cell_decor.parallaxAt(px0 + 0.5, py0 + 0.5));
+ }
+ }
+ if (cell_decor.title) |inks| {
+ if (resolved.role == .tagline and (std.mem.eql(u8, &resolved.fg, &inks[0]) or std.mem.eql(u8, &resolved.fg, &inks[1]))) instances[idx].effect |= title_bit;
+ }
+ }
}
test "block cursor alone overrides transparent cell background" {
var g: Gui = undefined;
+ g.words = .{};
g.cell_w = 10;
g.cell_h = 20;
g.space_slot = .{ .u = 0, .v = 0 };
const cell: pardes.Cell = .{};
var instances: [2]CellInstance = undefined;
for ([_]bool{ false, true }, 0..) |cursor, i| {
- emitInstance(&g, &instances, @intCast(i), 0, 0, fixedCellLayout(&g), 800, 480, null, .body, &cell, false, cursor, Ground.opaqueRgb(bg_default));
+ emitInstance(&g, &instances, @intCast(i), 0, 0, fixedCellLayout(&g), 800, 480, null, .body, (&cell)[0..1], 0, null, false, cursor, Ground.opaqueRgb(bg_default));
try std.testing.expectEqual(cursor, instances[i].effect & opaque_bg_bit != 0);
}
}
+test "lapis dots only the page's own ground and shadows only a file name, never a cursor" {
+ var g: Gui = undefined;
+ g.words = .{};
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 8;
+ g.tagline_height = 16;
+ g.space_slot = .{ .u = 0, .v = 0 };
+ const page: [3]u8 = .{ 0x0a, 0x10, 0x30 };
+ const name: [3]u8 = .{ 0xe8, 0xc4, 0x6a };
+ var chrome: pardes.Chrome = .{ .page = page, .decor_dots = .{ 1, 2, 3 }, .decor_dot_alpha = 0x22, .decor_title = .{ 4, 5, 6 }, .name_ink = name, .active_name_ink = name };
+ cell_decor = CellDecor.of(&chrome);
+ defer cell_decor = .{};
+ const on_page: pardes.Cell = .{ .default = false, .style = .{ .fg = .{ .rgb = .{ 200, 200, 200 } }, .bg = .{ .rgb = page } } };
+ const selected: pardes.Cell = .{ .default = false, .style = .{ .fg = .{ .rgb = .{ 0, 0, 0 } }, .bg = .{ .rgb = name } } };
+ const title: pardes.Cell = .{ .default = false, .style = .{ .fg = .{ .rgb = name }, .bg = .{ .rgb = .{ 0x0f, 0x1a, 0x4a } }, .font_role = .tagline } };
+ const plain_tag: pardes.Cell = .{ .default = false, .style = .{ .fg = .{ .rgb = .{ 0x9a, 0xa6, 0xd9 } }, .bg = .{ .rgb = .{ 0x0f, 0x1a, 0x4a } }, .font_role = .tagline } };
+ var instances: [1]CellInstance = undefined;
+ const Case = struct { cell: pardes.Cell, role: pardes.FontRole, cursor: bool, dotted: bool, shadowed: bool };
+ for ([_]Case{
+ .{ .cell = on_page, .role = .body, .cursor = false, .dotted = true, .shadowed = false },
+ .{ .cell = on_page, .role = .body, .cursor = true, .dotted = false, .shadowed = false },
+ .{ .cell = selected, .role = .body, .cursor = false, .dotted = false, .shadowed = false },
+ .{ .cell = title, .role = .tagline, .cursor = false, .dotted = false, .shadowed = true },
+ .{ .cell = title, .role = .tagline, .cursor = true, .dotted = false, .shadowed = false },
+ .{ .cell = plain_tag, .role = .tagline, .cursor = false, .dotted = false, .shadowed = false },
+ }) |case| {
+ emitInstance(&g, &instances, 0, 0, 0, fixedCellLayout(&g), 800, 480, null, case.role, (&case.cell)[0..1], 0, null, false, case.cursor, Ground.opaqueRgb(page));
+ try std.testing.expectEqual(case.dotted, instances[0].effect & dotted_bit != 0);
+ try std.testing.expectEqual(case.shadowed, instances[0].effect & title_bit != 0);
+ }
+ // A theme without decor marks nothing.
+ chrome = .{ .page = page };
+ cell_decor = CellDecor.of(&chrome);
+ emitInstance(&g, &instances, 0, 0, 0, fixedCellLayout(&g), 800, 480, null, .body, (&on_page)[0..1], 0, null, false, false, Ground.opaqueRgb(page));
+ try std.testing.expectEqual(@as(u32, 0), instances[0].effect & (dotted_bit | title_bit));
+}
+
+test "lapis plaques stay in their tag's band, clear of every grip; only the focused one is striped" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme lapis"));
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expect(s.chrome.decor_box_border != null and s.chrome.decor_checker != null and s.chrome.decor_dots != null and s.chrome.decor_title != null);
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 16;
+ g.cell_h = 32;
+ g.tagline_width = 12;
+ g.tagline_height = 22;
+ display_scale = 1;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 1280, 768, true);
+ const layout = fixedCellLayout(&g);
+ const under = g.decor.items[groups.items[0].decor_start..][0..groups.items[0].under_count];
+ try std.testing.expect(under.len != 0);
+ var stripes: usize = 0;
+ var shadows: usize = 0;
+ for (under) |item| {
+ const r: [4]f32 = .{ (item.x0 + 1) / 2 * 1280, (1 - item.y0) / 2 * 768, (item.x1 + 1) / 2 * 1280, (1 - item.y1) / 2 * 768 };
+ // Inside one tag's band, whole: never on a body, a grip or the
+ // next pane. A box stacked under another tag's lays its top frame
+ // over their shared edge, its own width up into the band above.
+ const home = for (s.regionList()) |region| {
+ if (region.kind != .tag and region.kind != .column_tag and region.kind != .workspace_tag) continue;
+ const band = plaqueBox(&g, &s.chrome, s.regionList(), region, layout, 1280, 768) orelse continue;
+ if (r[0] >= band.band[0] - 0.01 and r[1] >= band.band[1] - band.border - 0.01 and r[2] <= band.band[2] + 0.01 and r[3] <= band.band[3] + 0.01) break region;
+ } else return error.PlaqueOutsideItsBand;
+ // Clear of every grip's button: a plaque starts flush against it,
+ // in the gap between it and the text.
+ for (s.regionList()) |grip| {
+ if (grip.kind != .grip and grip.kind != .column_grip) continue;
+ const column = scrollColumn(&g, &s.chrome, grip.rect.x, layout);
+ const gx0 = column[0];
+ const gx1 = column[1];
+ const gy0 = @as(f32, @floatFromInt(grip.rect.y)) * 32;
+ const gy1 = @as(f32, @floatFromInt(grip.rect.y + grip.rect.h)) * 32;
+ try std.testing.expect(r[2] <= gx0 + 0.01 or r[0] >= gx1 - 0.01 or r[3] <= gy0 + 0.01 or r[1] >= gy1 - 0.01);
+ }
+ if (item.effect & checker_bit != 0) {
+ try std.testing.expect(home.kind == .tag and home.active);
+ stripes += 1;
+ }
+ const rgb: [3]u8 = .{ @intFromFloat(@round(item.br * 255)), @intFromFloat(@round(item.bg * 255)), @intFromFloat(@round(item.bb * 255)) };
+ if (std.mem.eql(u8, &rgb, &s.chrome.decor_box_shadow.?)) shadows += 1;
+ }
+ try std.testing.expectEqual(@as(usize, 1), stripes);
+ try std.testing.expect(shadows >= 2);
+ // Stacked boxes share an edge and line up: a column's box spans its
+ // first pane's across, runs down to the edge that pane's frame lies
+ // over, and no shadow reaches the next column.
+ var stacks: usize = 0;
+ for (s.regionList()) |column| {
+ if (column.kind != .column_tag) continue;
+ const upper = plaqueBox(&g, &s.chrome, s.regionList(), column, layout, 1280, 768).?;
+ for (s.regionList()) |tag| {
+ if (tag.kind != .tag or tag.rect.y != column.rect.y + column.rect.h or tag.rect.x + tag.rect.w != column.rect.x + column.rect.w) continue;
+ const lower = plaqueBox(&g, &s.chrome, s.regionList(), tag, layout, 1280, 768).?;
+ try std.testing.expectEqual(upper.box[0], lower.box[0]);
+ // Flush against the grips' buttons, which line up too.
+ const grip = for (s.regionList()) |part| {
+ if (part.kind == .grip and part.owner == tag.owner) break part;
+ } else unreachable;
+ try std.testing.expectEqual(scrollColumn(&g, &s.chrome, grip.rect.x, layout)[1], lower.box[0]);
+ try std.testing.expectEqual(upper.box[2], lower.box[2]);
+ try std.testing.expectEqual(upper.band[3], upper.box[3]);
+ try std.testing.expectEqual(lower.band[1] - lower.border, lower.box[1]);
+ try std.testing.expectEqual(@as(f32, 0), upper.shadow[1]);
+ if (lower.band[2] < 1280) try std.testing.expect(lower.box[2] + lower.shadow[0] < lower.band[2]);
+ stacks += 1;
+ }
+ }
+ try std.testing.expectEqual(@as(usize, 2), stacks);
+ // The scroll track is chequered.
+ var checkers: usize = 0;
+ for (g.decor.items[groups.items[0].decor_start + groups.items[0].under_count ..]) |item| checkers += @intFromBool(item.effect & checker_bit != 0);
+ try std.testing.expect(checkers >= 1);
+ // No other theme draws any of it.
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme forge"));
+ for (0..40) |_| core.update(.tick);
+ const plain = try core.render(core.scratch.allocator());
+ try std.testing.expect(plain.chrome.decor_box_border == null and plain.chrome.decor_checker == null and plain.chrome.decor_dots == null and plain.chrome.decor_title == null);
+}
+
fn cellCodepoint(cell: *const pardes.Cell) u32 {
const grapheme = cell.grapheme();
return if (cell.default or grapheme.len == 0) ' ' else firstCp(grapheme);
@@ -5722,24 +7570,28 @@ test "insert cursor overlays without replacing the character beneath it" {
};
try std.testing.expectEqual(@as(u32, 'x'), cellCodepoint(&cell));
- var vertices: [6]OverlayVertex = undefined;
- var builder: OverlayBuilder = .{
- .vertices = &vertices,
- .win_w = 100,
- .win_h = 100,
- };
- addCursorBar(&builder, 2, 3, true, 8, .{
- .x_off = 0,
- .y_off = 0,
- .w = 10,
- .h = 20,
- }, .{ 32, 48, 64 });
- try std.testing.expectEqual(@as(usize, 6), builder.len);
- try std.testing.expectApproxEqAbs(@as(f32, -0.32), vertices[0].y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, -0.48), vertices[2].y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 32.0 / 255.0), vertices[0].r, 0.0001);
- for (vertices) |vertex| try std.testing.expectEqual(@as(u32, 1), vertex.ink);
- try std.testing.expect(!builder.ink);
+ // A bar at a tag cell: tagline-tall, centered in its row, in the
+ // cell's ink, drawn as decor over it.
+ var cells: [25]pardes.Cell = @splat(.{});
+ cells[3 * 5 + 2] = .{ .default = false, .style = .{ .fg = .{ .rgb = .{ 32, 48, 64 } }, .font_role = .tagline } };
+ const surface: pardes.Surface = .{ .cols = 5, .rows = 5, .cells = &cells, .cursor = .{ .x = 2, .y = 3, .bar = true } };
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(std.testing.allocator);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 8;
+ g.tagline_height = 8;
+ try cursorDecor(&g, std.testing.allocator, &surface, fixedCellLayout(&g), 100, 100);
+ try std.testing.expectEqual(@as(usize, 1), g.decor.items.len);
+ const bar = g.decor.items[0];
+ try std.testing.expectApproxEqAbs(@as(f32, -0.32), bar.y0, 0.0001);
+ try std.testing.expectApproxEqAbs(@as(f32, -0.48), bar.y1, 0.0001);
+ try std.testing.expectApproxEqAbs(@as(f32, 32.0 / 255.0), bar.br, 0.0001);
+ try std.testing.expectEqual(@as(f32, 1), bar.fr);
}
fn palColor(idx: u8) [3]u8 {
@@ -5755,16 +7607,15 @@ fn firstCp(s: []const u8) u32 {
}
fn refitFont(g: *Gui, core: ?*pardes.Pardes) void {
- g.scale = c.ui_font_scale_for_height(g.font, g.px);
var cw: c_int = 10;
var chh: c_int = 20;
var asc: c_int = 16;
- c.ui_font_cell_metrics(g.font, g.scale, &cw, &chh, &asc);
+ c.ui_font_cell_metrics(g.font, g.px, &cw, &chh, &asc);
g.cell_w = @intCast(@max(cw, 1));
g.cell_h = @intCast(@max(chh, 1));
g.ascent = @intCast(@max(asc, 1));
const tagline = taglineRaster(g.font, g.px, g.cell_w, g.cell_h, g.tagline_percent);
- g.tagline_scale = tagline.scale;
+ g.tagline_px = tagline.px;
g.tagline_width = tagline.width;
g.tagline_baseline = tagline.baseline;
g.tagline_height = tagline.height;
@@ -5779,14 +7630,27 @@ fn refitFont(g: *Gui, core: ?*pardes.Pardes) void {
resetScroll(g);
}
+// The first cell of the cleared atlas stays blank: the space slot.
fn resetGlyphAtlas(g: *Gui) void {
g.glyphs.clearRetainingCapacity();
+ g.words.clear();
@memset(g.atlas_stage, 0);
- _ = c.ui_font_raster(g.font, g.scale, ' ', g.atlas_stage.ptr, @intCast(atlas_w), @intCast(g.cell_w), @intCast(g.cell_h), g.ascent);
g.space_slot = .{ .u = 0, .v = 0 };
g.pen_x = g.cell_w;
g.pen_y = 0;
- g.atlas_dirty = true;
+ g.atlas_dirty_top = 0;
+ g.atlas_dirty_bottom = atlas_h;
+}
+
+/// A changed Ligatures setting drops what was resolved under the old one: the
+/// per-codepoint cells (which say whether a cell is shaped) and the shaped
+/// words. The atlas keeps its glyphs, plain and strip alike; the plain ones
+/// draw either way, and the strips come back into use when ligatures do.
+/// The frame this runs before redraws every cell with the new setting.
+fn syncLigatures(g: *Gui, core: *pardes.Pardes) void {
+ if (core.settings.ligatures == g.words.ligatures) return;
+ g.words.clear();
+ g.words.ligatures = core.settings.ligatures;
}
fn syncTaglineFont(g: *Gui, core: *pardes.Pardes) void {
@@ -5794,7 +7658,7 @@ fn syncTaglineFont(g: *Gui, core: *pardes.Pardes) void {
if (percent == g.tagline_percent) return;
g.tagline_percent = percent;
const tagline = taglineRaster(g.font, g.px, g.cell_w, g.cell_h, percent);
- g.tagline_scale = tagline.scale;
+ g.tagline_px = tagline.px;
g.tagline_width = tagline.width;
g.tagline_baseline = tagline.baseline;
g.tagline_height = tagline.height;
@@ -5803,36 +7667,379 @@ fn syncTaglineFont(g: *Gui, core: *pardes.Pardes) void {
_ = updateCoreResize(core, geom.cols, geom.rows, g.cell_w, g.cell_h, g.tagline_width, g.tagline_height);
}
-fn ensureGlyph(g: *Gui, cp: u32, role: pardes.FontRole, decoration: GlyphDecoration) Slot {
- return cachedGlyph(g, cp, role, decoration, false) orelse g.space_slot;
+/// What text draws, so a frame does not work it out again. `cells` is the
+/// atlas slot of a codepoint no ligature can touch (`shape_slot` for one that
+/// is shaped with its word); `map` is the atlas slot of every cell of a word
+/// holding one, found by the word's text. Bounded: past `max_cells` word cells
+/// it starts over, and the next frames look up what they show again (the
+/// glyphs stay in the atlas).
+const Words = struct {
+ cells: std.AutoHashMapUnmanaged(CellKey, Slot) = .empty,
+ map: std.AutoHashMapUnmanaged(u64, Word) = .empty,
+ /// Every word's codepoints and slots, end to end; a Word indexes both.
+ text: std.ArrayListUnmanaged(u32) = .empty,
+ slots: std.ArrayListUnmanaged(Slot) = .empty,
+ shaped: std.ArrayListUnmanaged(c.UIShapedCell) = .empty,
+ /// The Ligatures setting. Off, no cell is shaped, so each draws its own
+ /// glyph, as in a font without ligatures. It lives here because every
+ /// cell and word above was resolved under it (`syncLigatures`).
+ ligatures: bool = true,
+ /// The word the last cell was in, so the rest of it costs a compare. It
+ /// is positional, so every frame forgets it: the cells change under it.
+ memo: Memo = .{},
+
+ const max_cells = 1 << 17;
+ const CellKey = packed struct(u64) { cp: u21, role: pardes.FontRole, decoration: GlyphDecoration, _: u30 = 0 };
+ const shape_slot: Slot = .{ .u = std.math.maxInt(u32), .v = std.math.maxInt(u32) };
+ const Word = struct { start: u32, len: u32, decoration: GlyphDecoration };
+ const Memo = struct {
+ line: ?[*]const pardes.Cell = null,
+ len: usize = 0,
+ start: usize = 0,
+ end: usize = 0,
+ cursor: ?usize = null,
+ slots: usize = 0,
+ };
+
+ fn clear(w: *Words) void {
+ w.cells.clearRetainingCapacity();
+ w.map.clearRetainingCapacity();
+ w.text.clearRetainingCapacity();
+ w.slots.clearRetainingCapacity();
+ w.memo = .{};
+ }
+
+ fn deinit(w: *Words, gpa: std.mem.Allocator) void {
+ w.cells.deinit(gpa);
+ w.map.deinit(gpa);
+ w.text.deinit(gpa);
+ w.slots.deinit(gpa);
+ w.shaped.deinit(gpa);
+ }
+};
+
+/// What decides where a word ends, for one cell. A concealed cell is a space.
+const WordCell = struct { cp: u32, decoration: GlyphDecoration, role: pardes.FontRole };
+
+fn wordCell(cell: *const pardes.Cell) WordCell {
+ return .{
+ .cp = if (!cell.default and cell.style.invisible) ' ' else cellCodepoint(cell),
+ .decoration = GlyphDecoration.fromCell(cell),
+ .role = cellFontRole(cell),
+ };
+}
+
+/// Whether a word ends between `a`, cell `i`, and `b`, cell `i + 1`: at a
+/// space, a decoration or role change, either side of the cursor (Ghostty's
+/// rule: the cell being edited shows its own glyph, so a ligature under the
+/// cursor comes apart), and inside f|i, f|l and s|t, whose typographic
+/// ligatures do not belong on a grid (Ghostty again). Colours never end a
+/// word: a ligature spans a syntax colour change or a selection edge, and each
+/// cell tints its own slice.
+fn wordBreak(a: WordCell, b: WordCell, i: usize, cursor: ?usize) bool {
+ if (a.cp == ' ' or b.cp == ' ') return true;
+ // A rule is drawn by hand (ruleArms), never a slice of a shaped word.
+ if (ruleArms(a.cp) != null or ruleArms(b.cp) != null) return true;
+ if (cursor) |at| if (at == i or at == i + 1) return true;
+ if (a.role != b.role or !std.meta.eql(a.decoration, b.decoration)) return true;
+ return (a.cp == 'f' and (b.cp == 'i' or b.cp == 'l')) or (a.cp == 's' and b.cp == 't');
+}
+
+/// The atlas slot `line[at]` draws: blank for a plain space (or concealed
+/// text), its own glyph when no ligature could replace that glyph (every
+/// cell, in a font without ligatures or with Ligatures off), else its slice
+/// of the word around it, shaped once and cached by the word's text. The
+/// cells of a word being walked cost a compare. Taglines are not shaped: they are drawn at two pitches
+/// (tagline_width in a tag layer, a whole cell in the grid), and a strip would
+/// not line up in one of them.
+fn cellSlot(g: *Gui, line: []const pardes.Cell, at: usize, cursor: ?usize, role: pardes.FontRole) Slot {
+ const words = &g.words;
+ const memo = words.memo;
+ if (memo.line == line.ptr and memo.len == line.len and memo.cursor == cursor and at >= memo.start and at < memo.end and role == .body)
+ return words.slots.items[memo.slots + at - memo.start];
+ var here = wordCell(&line[at]);
+ // An underlined or struck-out space is a glyph of its own: it draws its line.
+ if (here.cp == ' ' and !here.decoration.drawsBlank()) return g.space_slot;
+ if (ruleArms(here.cp) != null)
+ return cachedGlyph(g, .{ .face = 0, .glyph = here.cp, .role = role, .rule = true }) orelse g.space_slot;
+ const gpa = g.glyphs.allocator;
+ const cell_key: Words.CellKey = .{ .cp = @intCast(here.cp), .role = role, .decoration = here.decoration };
+ const known = words.cells.getOrPut(gpa, cell_key) catch return g.space_slot;
+ if (!known.found_existing) {
+ const drawn = glyphForCodepoint(g, here.cp);
+ const font = if (drawn.face == 0) g.font else g.fallbacks[drawn.face - 1].?.face;
+ known.value_ptr.* = if (role == .body and words.ligatures and c.ui_font_substitutes(font, drawn.glyph) != 0)
+ Words.shape_slot
+ else
+ cachedGlyph(g, .{ .face = drawn.face, .glyph = drawn.glyph, .role = role, .decoration = here.decoration }) orelse g.space_slot;
+ }
+ const plain = known.value_ptr.*;
+ if (!std.meta.eql(plain, Words.shape_slot)) return plain;
+
+ if (words.text.items.len > Words.max_cells) words.clear();
+ var start = at;
+ while (start > 0) {
+ const before = wordCell(&line[start - 1]);
+ if (wordBreak(before, here, start - 1, cursor)) break;
+ start -= 1;
+ here = before;
+ }
+ // The word's text goes on the end of `text`: a new word keeps it there,
+ // a known one gives it back.
+ const text_start = words.text.items.len;
+ var end = start;
+ while (true) {
+ words.text.append(gpa, here.cp) catch return g.space_slot;
+ end += 1;
+ if (end == line.len) break;
+ const next = wordCell(&line[end]);
+ if (wordBreak(here, next, end - 1, cursor)) break;
+ here = next;
+ }
+ const text = words.text.items[text_start..];
+ const decoration = here.decoration;
+ const hash = std.hash.Wyhash.hash(@as(u5, @bitCast(decoration)), std.mem.sliceAsBytes(text));
+ if (words.map.get(hash)) |word| {
+ if (word.len == text.len and std.meta.eql(word.decoration, decoration) and
+ std.mem.eql(u32, words.text.items[word.start..][0..word.len], text))
+ {
+ words.text.shrinkRetainingCapacity(text_start);
+ words.memo = .{ .line = line.ptr, .len = line.len, .start = start, .end = end, .cursor = cursor, .slots = word.start };
+ return words.slots.items[word.start + at - start];
+ }
+ }
+
+ // A new word (a hash collision takes the map entry over). Runs of one
+ // face are shaped in that face; fallback faces shape like the primary.
+ const probe_shape = monoNs();
+ defer if (frame_probe) |probe| {
+ probe.zone(.gui_shape, probe_shape);
+ probe.shaped +|= 1;
+ };
+ const n = text.len;
+ words.slots.ensureUnusedCapacity(gpa, n) catch {
+ words.text.shrinkRetainingCapacity(text_start);
+ return g.space_slot;
+ };
+ words.shaped.resize(gpa, n) catch {
+ words.text.shrinkRetainingCapacity(text_start);
+ return g.space_slot;
+ };
+ const shaped = words.shaped.items;
+ var run_start: usize = 0;
+ var face = glyphForCodepoint(g, text[0]).face;
+ while (run_start < n) {
+ var run_end = run_start + 1;
+ var next_face = face;
+ while (run_end < n) : (run_end += 1) {
+ next_face = glyphForCodepoint(g, text[run_end]).face;
+ if (next_face != face) break;
+ }
+ const run_font = if (face == 0) g.font else g.fallbacks[face - 1].?.face;
+ c.ui_font_shape(run_font, g.px, @intCast(g.cell_w), text[run_start..].ptr, @intCast(run_end - run_start), shaped[run_start..].ptr);
+ for (shaped[run_start..run_end]) |cell| {
+ const key: GlyphKey = .{ .face = face, .glyph = cell.glyph, .role = .body, .decoration = decoration, .lead = @intCast(cell.lead), .span = @intCast(cell.span) };
+ const slot: Slot = if (cachedGlyph(g, key)) |strip| .{ .u = strip.u + g.cell_w * cell.slice, .v = strip.v } else g.space_slot;
+ words.slots.appendAssumeCapacity(slot);
+ }
+ run_start = run_end;
+ face = next_face;
+ }
+ words.map.put(gpa, hash, .{ .start = @intCast(text_start), .len = @intCast(n), .decoration = decoration }) catch {};
+ words.memo = .{ .line = line.ptr, .len = line.len, .start = start, .end = end, .cursor = cursor, .slots = text_start };
+ return words.slots.items[text_start + at - start];
+}
+
+/// A Gui that can shape and rasterize `font` at `px`, and nothing else. From
+/// here on the fonts allocate from std.testing.allocator (the caller puts
+/// font_allocator back), so the test counts what they leak.
+fn textTestGui(font: *c.UIFont, px: f32) !Gui {
+ c.ui_font_prime(font);
+ font_allocator = std.testing.allocator;
+ var g: Gui = undefined;
+ g.font = font;
+ g.fallback_count = 0;
+ g.px = px;
+ var cw: c_int = 0;
+ var ch: c_int = 0;
+ c.ui_font_cell_metrics(font, px, &cw, &ch, &g.ascent);
+ g.cell_w = @intCast(cw);
+ g.cell_h = @intCast(ch);
+ const tag = taglineRaster(font, px, g.cell_w, g.cell_h, 82);
+ g.tagline_px = tag.px;
+ g.tagline_width = tag.width;
+ g.tagline_height = tag.height;
+ g.tagline_baseline = tag.baseline;
+ g.atlas_stage = try std.testing.allocator.alloc(u8, atlas_w * atlas_h);
+ g.glyphs = std.AutoHashMap(GlyphKey, Slot).init(std.testing.allocator);
+ g.words = .{};
+ resetGlyphAtlas(&g);
+ return g;
+}
+
+fn textTestLine(comptime text: []const u8) [text.len]pardes.Cell {
+ var line: [text.len]pardes.Cell = @splat(.{ .default = false });
+ for (&line, text) |*cell, byte| cell.text[0] = byte;
+ return line;
}
-fn cachedGlyph(g: *Gui, cp: u32, role: pardes.FontRole, decoration: GlyphDecoration, centered: bool) ?Slot {
- const key: GlyphKey = .{ .codepoint = cp, .role = role, .decoration = decoration, .centered = centered };
- const slot_w = g.cell_w * @as(u32, if (centered) config.GUTTER else 1);
+test "a ligature draws across its cells, one slice each, and comes apart under the cursor" {
+ const bytes = try filesystem.readFile(std.testing.allocator, "assets/MapleMono-NF-Regular.ttf");
+ defer std.testing.allocator.free(bytes);
+ const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit;
+ defer c.ui_font_free(font);
+ var g = try textTestGui(font, 27);
+ defer font_allocator = std.heap.smp_allocator;
+ defer std.testing.allocator.free(g.atlas_stage);
+ defer g.glyphs.deinit();
+ defer g.words.deinit(std.testing.allocator);
+
+ const line = textTestLine("a->b");
+ var slots: [4]Slot = undefined;
+ for (&slots, 0..) |*slot, i| slot.* = cellSlot(&g, &line, i, null, .body);
+ // `->` is one glyph strip two cells wide: each cell samples its own half.
+ try std.testing.expectEqual(slots[1].v, slots[2].v);
+ try std.testing.expectEqual(slots[1].u + g.cell_w, slots[2].u);
+ var strips: usize = 0;
+ var it = g.glyphs.iterator();
+ while (it.next()) |entry| if (entry.key_ptr.span == 2) {
+ strips += 1;
+ try std.testing.expectEqual(@as(u4, 1), entry.key_ptr.lead);
+ try std.testing.expectEqual(slots[1], entry.value_ptr.*);
+ };
+ try std.testing.expectEqual(@as(usize, 1), strips);
+ // The arrow runs through the seam: both halves carry ink at it.
+ const seam = g.atlas_stage[@as(usize, slots[2].v) * atlas_w ..];
+ var left_ink: usize = 0;
+ var right_ink: usize = 0;
+ for (0..g.cell_h) |y| {
+ left_ink += seam[y * atlas_w + slots[2].u - 1];
+ right_ink += seam[y * atlas_w + slots[2].u];
+ }
+ try std.testing.expect(left_ink > 0 and right_ink > 0);
+ // `a` and `b` are their plain glyphs.
+ try std.testing.expectEqual(g.glyphs.get(.{ .face = 0, .glyph = c.ui_font_glyph(font, 'a'), .role = .body }).?, slots[0]);
+ try std.testing.expectEqual(g.glyphs.get(.{ .face = 0, .glyph = c.ui_font_glyph(font, 'b'), .role = .body }).?, slots[3]);
+
+ // A second line with the same word reuses the shaped slots.
+ const again = textTestLine("a->b");
+ const text_len = g.words.text.items.len;
+ for (0..4) |i| try std.testing.expectEqual(slots[i], cellSlot(&g, &again, i, null, .body));
+ try std.testing.expectEqual(text_len, g.words.text.items.len);
+
+ // The cursor on either half shows plain `-` and `>`.
+ const plain_minus = cachedGlyph(&g, .{ .face = 0, .glyph = c.ui_font_glyph(font, '-'), .role = .body }).?;
+ const plain_greater = cachedGlyph(&g, .{ .face = 0, .glyph = c.ui_font_glyph(font, '>'), .role = .body }).?;
+ for ([_]usize{ 1, 2 }) |cursor| {
+ try std.testing.expectEqual(plain_minus, cellSlot(&g, &line, 1, cursor, .body));
+ try std.testing.expectEqual(plain_greater, cellSlot(&g, &line, 2, cursor, .body));
+ }
+ // A tagline is never shaped.
+ try std.testing.expectEqual(c.ui_font_glyph(font, '-'), (try glyphKeyAt(&g, cellSlot(&g, &line, 1, null, .tagline))).glyph);
+}
+
+test "Ligatures off draws a ligature as its cells' own glyphs, and on shapes it again" {
+ const bytes = try filesystem.readFile(std.testing.allocator, "assets/MapleMono-NF-Regular.ttf");
+ defer std.testing.allocator.free(bytes);
+ const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse return error.FontInit;
+ defer c.ui_font_free(font);
+ var g = try textTestGui(font, 27);
+ defer font_allocator = std.heap.smp_allocator;
+ defer std.testing.allocator.free(g.atlas_stage);
+ defer g.glyphs.deinit();
+ defer g.words.deinit(std.testing.allocator);
+ const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+
+ const text = "a->b";
+ const line = textTestLine(text);
+ var shaped: [text.len]Slot = undefined;
+ for (&shaped, 0..) |*slot, i| slot.* = cellSlot(&g, &line, i, null, .body);
+ try std.testing.expectEqual(shaped[1].u + g.cell_w, shaped[2].u);
+
+ // Off, every cell is the slot the per-glyph path gives its codepoint.
+ try std.testing.expect(core.executeBuiltinLine(core.active, "Ligatures off"));
+ syncLigatures(&g, core);
+ for (text, 0..) |byte, i| {
+ const plain = cachedGlyph(&g, .{ .face = 0, .glyph = c.ui_font_glyph(font, byte), .role = .body }).?;
+ try std.testing.expectEqual(plain, cellSlot(&g, &line, i, null, .body));
+ }
+ try std.testing.expect(!std.meta.eql(shaped[1], cellSlot(&g, &line, 1, null, .body)));
+
+ // On again, the arrow is its strip once more.
+ try std.testing.expect(core.executeBuiltinLine(core.active, "Ligatures on"));
+ syncLigatures(&g, core);
+ for (shaped, 0..) |slot, i| try std.testing.expectEqual(slot, cellSlot(&g, &line, i, null, .body));
+}
+
+fn glyphKeyAt(g: *Gui, slot: Slot) !GlyphKey {
+ var it = g.glyphs.iterator();
+ while (it.next()) |entry| if (std.meta.eql(entry.value_ptr.*, slot)) return entry.key_ptr.*;
+ return error.NoGlyph;
+}
+
+test "a font without ligatures draws every cell as its own glyph, exactly as before shaping" {
+ const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ defer c.ui_font_free(font);
+ var g = try textTestGui(font, 18);
+ defer font_allocator = std.heap.smp_allocator;
+ defer std.testing.allocator.free(g.atlas_stage);
+ defer g.glyphs.deinit();
+ defer g.words.deinit(std.testing.allocator);
+ const text = "a->b != c => d <= e |> www == :: 0x1F";
+ var line = textTestLine(text);
+ line[3].style.bold = true; // a style change inside a word
+ var expected: [64 * 64]u8 = undefined;
+ for (line, 0..) |cell, i| {
+ if (text[i] == ' ') continue;
+ const slot = cellSlot(&g, &line, i, null, .body);
+ const key = try glyphKeyAt(&g, slot);
+ try std.testing.expectEqual(c.ui_font_glyph(font, text[i]), key.glyph);
+ try std.testing.expectEqual(@as(u4, 1), key.span);
+ _ = c.ui_font_raster(font, 18, key.glyph, @intFromBool(cell.style.bold), &expected, 64, @intCast(g.cell_w), @intCast(g.cell_h), 0, @intCast(g.cell_w), g.ascent);
+ for (0..g.cell_h) |y|
+ try std.testing.expectEqualSlices(u8, expected[y * 64 ..][0..g.cell_w], g.atlas_stage[(slot.v + y) * atlas_w + slot.u ..][0..g.cell_w]);
+ }
+}
+
+/// The atlas slot of `key`, rasterized on first use. A strip is `span` cells
+/// wide (a grip glyph GUTTER cells, centered); a cell samples its slice of it.
+/// Null when the atlas is full.
+fn cachedGlyph(g: *Gui, key: GlyphKey) ?Slot {
if (g.glyphs.get(key)) |s| return s;
+ const slot_w = g.cell_w * @as(u32, if (key.centered) config.GUTTER else key.span);
if (g.pen_x + slot_w > atlas_w) {
g.pen_x = 0;
g.pen_y += g.cell_h;
}
if (g.pen_y + g.cell_h > atlas_h) return null; // atlas full: fall back
+ const probe_raster = monoNs();
+ defer if (frame_probe) |probe| {
+ probe.zone(.gui_raster, probe_raster);
+ probe.rastered +|= 1;
+ };
const s = Slot{ .u = g.pen_x, .v = g.pen_y };
const out = g.atlas_stage.ptr + @as(usize, s.v) * atlas_w + s.u;
- const face = fontForCodepoint(g, cp);
- const scale = if (role == .tagline) g.tagline_scale else g.scale;
- const baseline = if (role == .tagline) g.tagline_baseline else g.ascent;
- const raster_w = if (centered) slot_w else if (role == .tagline) g.tagline_width else g.cell_w;
- const raster_h = if (role == .tagline) g.tagline_height else g.cell_h;
- if (centered) {
- _ = c.ui_font_raster_centered(face, scale, @intCast(cp), out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h));
+ const face = if (key.face == 0) g.font else g.fallbacks[key.face - 1].?.face;
+ const px = if (key.role == .tagline) g.tagline_px else g.px;
+ const baseline = if (key.role == .tagline) g.tagline_baseline else g.ascent;
+ const cell_w = if (key.role == .tagline) g.tagline_width else g.cell_w;
+ const raster_w = if (key.centered) slot_w else cell_w * key.span;
+ const raster_h = if (key.role == .tagline) g.tagline_height else g.cell_h;
+ const bold = @intFromBool(key.decoration.bold);
+ if (key.rule) {
+ drawRule(out, atlas_w, raster_w, raster_h, ruleArms(key.glyph).?);
+ } else if (key.centered) {
+ _ = c.ui_font_raster_centered(face, px, key.glyph, bold, out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h));
} else {
- _ = c.ui_font_raster(face, scale, @intCast(cp), out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h), baseline);
+ _ = c.ui_font_raster(face, px, key.glyph, bold, out, @intCast(atlas_w), @intCast(raster_w), @intCast(raster_h), @intCast(cell_w * key.lead), @intCast(cell_w), baseline);
}
- decorateGlyph(out, atlas_w, raster_w, raster_h, baseline, decoration);
- if (centered) centerGlyphInk(out, raster_w, raster_h);
+ decorateLine(out, atlas_w, raster_w, raster_h, baseline, key.decoration);
+ if (key.centered) centerGlyphInk(out, raster_w, raster_h);
+ g.atlas_dirty_top = @min(g.atlas_dirty_top, s.v);
+ g.atlas_dirty_bottom = @max(g.atlas_dirty_bottom, s.v + raster_h);
g.glyphs.put(key, s) catch return null;
g.pen_x += slot_w;
- g.atlas_dirty = true;
return s;
}
@@ -5868,23 +8075,25 @@ test "pane indicator cached ink centers bearings styles and sizes" {
defer std.testing.allocator.free(g.atlas_stage);
g.glyphs = std.AutoHashMap(GlyphKey, Slot).init(std.testing.allocator);
defer g.glyphs.deinit();
+ g.words = .{};
for ([_]f32{ 13, 27, 40 }) |px| {
- g.scale = c.ui_font_scale_for_height(font, px);
+ g.px = px;
var cw: c_int = 0;
var ch: c_int = 0;
- c.ui_font_cell_metrics(font, g.scale, &cw, &ch, &g.ascent);
+ c.ui_font_cell_metrics(font, px, &cw, &ch, &g.ascent);
g.cell_w = @intCast(cw);
g.cell_h = @intCast(ch);
for ([_]u8{ 40, 82, 100 }) |percent| {
const tag = taglineRaster(font, px, g.cell_w, g.cell_h, percent);
g.tagline_width = tag.width;
g.tagline_height = tag.height;
- g.tagline_scale = tag.scale;
+ g.tagline_px = tag.px;
g.tagline_baseline = tag.baseline;
resetGlyphAtlas(&g);
try std.testing.expectEqual(@as(usize, 0), g.glyphs.count());
for ([_]u32{ '^', '$', 'j' }) |cp| for ([_]bool{ false, true }) |bold| {
- const slot = cachedGlyph(&g, cp, .tagline, .{ .bold = bold }, true).?;
+ const key: GlyphKey = .{ .face = 0, .glyph = c.ui_font_glyph(font, @intCast(cp)), .role = .tagline, .decoration = .{ .bold = bold }, .centered = true };
+ const slot = cachedGlyph(&g, key).?;
const bounds = inkBounds(g.atlas_stage[@as(usize, slot.v) * atlas_w + slot.u ..], atlas_w, g.cell_w * config.GUTTER, tag.height).?;
const center_x: isize = @intCast(bounds.min_x + bounds.max_x);
const center_y: isize = @intCast(bounds.min_y + bounds.max_y);
@@ -5892,7 +8101,7 @@ test "pane indicator cached ink centers bearings styles and sizes" {
try std.testing.expect(@abs(center_y - @as(isize, @intCast(tag.height - 1))) <= 1);
const count = g.glyphs.count();
const pen = g.pen_x;
- try std.testing.expectEqualDeep(slot, cachedGlyph(&g, cp, .tagline, .{ .bold = bold }, true).?);
+ try std.testing.expectEqualDeep(slot, cachedGlyph(&g, key).?);
try std.testing.expectEqual(count, g.glyphs.count());
try std.testing.expectEqual(pen, g.pen_x);
};
@@ -5900,7 +8109,7 @@ test "pane indicator cached ink centers bearings styles and sizes" {
}
resetGlyphAtlas(&g);
g.pen_y = atlas_h;
- try std.testing.expectEqual(@as(?Slot, null), cachedGlyph(&g, '^', .tagline, .{}, true));
+ try std.testing.expectEqual(@as(?Slot, null), cachedGlyph(&g, .{ .face = 0, .glyph = c.ui_font_glyph(font, '^'), .role = .tagline, .centered = true }));
}
test "pane indicator halves share dissolve changes and safe exhausted atlas" {
@@ -5908,19 +8117,32 @@ test "pane indicator halves share dissolve changes and safe exhausted atlas" {
cells[0].text[0] = '$';
var previous = cells;
previous[0].text[0] = '^';
- var layers = [_]pardes.TagLayer{.{ .kind = .pane, .serial = 1, .viewport = .{ .x = pardes.TAG_TEXT_INSET, .y = 0, .w = 3, .h = 1 }, .cols = 3 }};
var diffs: [12]pardes.PanelCellDiff = @splat(.unchanged);
diffs[0] = pardes.PanelCellDiff.between(&previous[0], &cells[0]);
- var surface: pardes.Surface = .{ .cols = 6, .rows = 2, .cells = &cells, .previous_cells = &previous, .previous_tag_layers = &layers, .cell_diffs = &diffs };
- surface.tag_layers[0] = layers[0];
- try std.testing.expect(gripCellChanged(&surface, 0, 0));
- try std.testing.expect(gripCellChanged(&surface, 1, 0));
- try std.testing.expect(!gripCellChanged(&surface, 2, 0));
- try std.testing.expect(paneGripCell(surface.tagLayers(), &cells, 6, 2, 0) == null);
- layers[0].kind = .column;
- try std.testing.expect(paneGripCell(&layers, &cells, 6, 0, 0) == null);
+ const surface: pardes.Surface = .{ .cols = 6, .rows = 2, .cells = &cells, .previous_cells = &previous, .cell_diffs = &diffs };
+ // A grip two cells wide at the top left, in both frames.
+ const grip = [_]pardes.Region{.{ .kind = .grip, .serial = 1, .rect = .{ .x = 0, .y = 0, .w = 2, .h = 1 } }};
+ var cover: [12]Cover = undefined;
+ var previous_cover: [12]Cover = undefined;
+ coverFrame(&cover, 6, 2, &.{}, &.{}, &grip);
+ coverFrame(&previous_cover, 6, 2, &.{}, &.{}, &grip);
+ try std.testing.expect(gripCellChanged(&surface, &cover, &previous_cover, 0, 0));
+ try std.testing.expect(gripCellChanged(&surface, &cover, &previous_cover, 1, 0));
+ try std.testing.expect(!gripCellChanged(&surface, &cover, &previous_cover, 2, 0));
+ try std.testing.expect(!cover[2].grip);
+ // A column's grip is a button too, cut the same way (it has no glyph).
+ coverFrame(&cover, 6, 2, &.{}, &.{}, &.{.{ .kind = .column_grip, .rect = .{ .x = 0, .y = 0, .w = 2, .h = 1 } }});
+ try std.testing.expect(cover[0].grip);
+ coverFrame(&cover, 6, 2, &.{}, &.{}, &grip);
+ const chrome: pardes.Chrome = .{};
+ const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ defer c.ui_font_free(font);
var g: Gui = undefined;
+ g.font = font;
+ g.fallback_count = 0;
+ g.px = 20;
+ g.tagline_px = 16;
g.cell_w = 10;
g.cell_h = 20;
g.tagline_width = 8;
@@ -5930,11 +8152,13 @@ test "pane indicator halves share dissolve changes and safe exhausted atlas" {
g.pen_y = atlas_h;
g.glyphs = std.AutoHashMap(GlyphKey, Slot).init(std.testing.allocator);
defer g.glyphs.deinit();
+ g.words = .{};
+ defer g.words.deinit(std.testing.allocator);
for ([_]bool{ false, true }) |old| {
var instances: [4]CellInstance = undefined;
var next: u32 = 0;
for (0..2) |col| {
- emitSurfaceCell(&g, null, &instances, &next, @intCast(col), 0, fixedCellLayout(&g), 100, 100, null, &cells[col], &cells[2], .{ .cell = &cells[0], .offset = @intCast(col) }, old, false, Ground.opaqueRgb(bg_default));
+ emitSurfaceCell(&g, &chrome, &instances, &next, @intCast(col), 0, fixedCellLayout(&g), 100, 100, null, cells[0..6], cover[0..6], col, null, old, false, Ground.opaqueRgb(bg_default));
try std.testing.expectEqual(@as(f32, 0), instances[col * 2 + 1].u0);
try std.testing.expectEqual(old, instances[col * 2 + 1].effect & old_layer_bit != 0);
}
@@ -5942,51 +8166,63 @@ test "pane indicator halves share dissolve changes and safe exhausted atlas" {
}
}
-// Decorations stay inside the existing atlas slot, so text advance, caret and
-// selection geometry are identical to the regular glyph. The cached mask keeps
-// this work out of steady-state rendering and also decorates terminal spaces.
-fn decorateGlyph(out: [*]u8, stride: usize, width: usize, height: usize, baseline: i32, decoration: GlyphDecoration) void {
+// Underline and strikethrough stay inside the existing atlas slot, so text
+// advance, caret and selection geometry are identical to the regular glyph.
+// The cached mask keeps this work out of steady-state rendering and also
+// decorates terminal spaces. Bold is not drawn here: the rasterizer emboldens
+// the outline.
+fn decorateLine(out: [*]u8, stride: usize, width: usize, height: usize, baseline: i32, decoration: GlyphDecoration) void {
if (width == 0 or height == 0) return;
- if (decoration.bold) {
- // A fractional one-pixel embolden preserves counters at small UI sizes.
- // Right-to-left traversal reads the original left neighbour each time.
- for (0..height) |y| {
- var x = width - 1;
- while (x > 0) : (x -= 1) {
- const previous = out[y * stride + x - 1];
- const target = &out[y * stride + x];
- target.* = @max(target.*, @as(u8, @intCast(@as(u16, previous) * 3 / 4)));
- }
- }
- }
+ // A line is a logical pixel thick, its dots and waves as long: the same
+ // weight at any density (dp).
+ const t: usize = @intFromFloat(dp(1));
if (decoration.underline != .off) {
const base: usize = @intCast(@max(0, baseline));
- const row = @min(base + 1, height - 1);
+ const row = @min(base + 1, height -| t);
for (0..width) |x| {
- switch (decoration.underline) {
+ const top = switch (decoration.underline) {
.off => unreachable,
- .single => out[row * stride + x] = 255,
+ .single => row,
.double => {
- const upper = @min(base + 1, height -| 3);
- out[upper * stride + x] = 255;
- out[@min(upper + 2, height - 1) * stride + x] = 255;
- },
- .curly => out[(row -| @as(usize, if (x % 4 < 2) 1 else 0)) * stride + x] = 255,
- .dotted => if (x % 3 == 0) {
- out[row * stride + x] = 255;
- },
- .dashed => if (x % 6 < 4) {
- out[row * stride + x] = 255;
+ const upper = @min(base + 1, height -| 3 * t);
+ for (0..t) |k| {
+ out[@min(upper + k, height - 1) * stride + x] = 255;
+ out[@min(upper + 2 * t + k, height - 1) * stride + x] = 255;
+ }
+ continue;
},
- }
+ .curly => row -| @as(usize, if (x % (4 * t) < 2 * t) t else 0),
+ .dotted => if (x % (3 * t) < t) row else continue,
+ .dashed => if (x % (6 * t) < 4 * t) row else continue,
+ };
+ for (0..t) |k| out[@min(top + k, height - 1) * stride + x] = 255;
}
}
if (decoration.strikethrough) {
- const row = @min(height - 1, @as(usize, @intCast(@max(0, baseline))) * 2 / 3);
- @memset(out[row * stride ..][0..width], 255);
+ const row = @min(height -| t, @as(usize, @intCast(@max(0, baseline))) * 2 / 3);
+ for (0..t) |k| @memset(out[@min(row + k, height - 1) * stride ..][0..width], 255);
}
}
+test "a box-drawing rule reaches its cell's edges, and only its arms do" {
+ const stride = 12;
+ const width = 9;
+ const height = 15;
+ var mask: [stride * height]u8 = @splat(0xa5);
+ drawRule(&mask, stride, width, height, ruleArms(0x253c).?);
+ // ┼: ink on all four edges, none in the corners, nothing past the slot.
+ try std.testing.expectEqual(@as(u8, 255), mask[0 * stride + width / 2]);
+ try std.testing.expectEqual(@as(u8, 255), mask[(height - 1) * stride + width / 2]);
+ try std.testing.expectEqual(@as(u8, 255), mask[(height / 2) * stride]);
+ try std.testing.expectEqual(@as(u8, 255), mask[(height / 2) * stride + width - 1]);
+ try std.testing.expectEqual(@as(u8, 0), mask[0]);
+ for (0..height) |y| for (mask[y * stride + width ..][0 .. stride - width]) |guard| try std.testing.expectEqual(@as(u8, 0xa5), guard);
+ drawRule(&mask, stride, width, height, ruleArms(0x2502).?);
+ try std.testing.expectEqual(@as(u8, 0), mask[(height / 2) * stride]);
+ try std.testing.expectEqual(@as(u8, 255), mask[0 * stride + width / 2]);
+ try std.testing.expect(ruleArms('|') == null);
+}
+
test "glyph decorations render spaces and stay inside their atlas slot" {
const stride = 9;
const width = 5;
@@ -6001,7 +8237,7 @@ test "glyph decorations render spaces and stay inside their atlas slot" {
}) |decoration| {
var mask: [stride * (height + 1)]u8 = @splat(0xa5);
for (0..height) |y| @memset(mask[y * stride ..][0..width], 0);
- decorateGlyph(&mask, stride, width, height, 5, decoration);
+ decorateLine(&mask, stride, width, height, 5, decoration);
try std.testing.expect(inkBounds(&mask, stride, width, height) != null);
for (0..height) |y| for (mask[y * stride + width ..][0 .. stride - width]) |guard|
try std.testing.expectEqual(@as(u8, 0xa5), guard);
@@ -6011,18 +8247,69 @@ test "glyph decorations render spaces and stay inside their atlas slot" {
try std.testing.expect(!GlyphDecoration.fromCell(&hidden).drawsBlank());
}
+/// Uploads only the atlas rows drawn into since the last upload. Glyphs fill
+/// the atlas pen-style, a band of rows at a time, so new glyphs are a band a
+/// cell or two tall, not the whole 4 MB texture. The band sits at the same
+/// offset in the transfer buffer as in the stage, and the texture keeps the
+/// rows outside it.
fn uploadAtlas(g: *Gui, cmd: *c.SDL_GPUCommandBuffer) void {
+ const top = g.atlas_dirty_top;
+ const rows = g.atlas_dirty_bottom - top;
const ptr = c.SDL_MapGPUTransferBuffer(g.device, g.atlas_xfer, false) orelse return;
const dst: [*]u8 = @ptrCast(ptr);
- @memcpy(dst[0 .. atlas_w * atlas_h], g.atlas_stage);
+ @memcpy(dst[top * atlas_w ..][0 .. rows * atlas_w], g.atlas_stage[top * atlas_w ..][0 .. rows * atlas_w]);
c.SDL_UnmapGPUTransferBuffer(g.device, g.atlas_xfer);
const copy = c.SDL_BeginGPUCopyPass(cmd);
- const src = c.SDL_GPUTextureTransferInfo{ .transfer_buffer = g.atlas_xfer, .offset = 0, .pixels_per_row = atlas_w, .rows_per_layer = atlas_h };
- const dstregion = c.SDL_GPUTextureRegion{ .texture = g.atlas_tex, .mip_level = 0, .layer = 0, .x = 0, .y = 0, .z = 0, .w = atlas_w, .h = atlas_h, .d = 1 };
+ const src = c.SDL_GPUTextureTransferInfo{ .transfer_buffer = g.atlas_xfer, .offset = top * atlas_w, .pixels_per_row = atlas_w, .rows_per_layer = rows };
+ const dstregion = c.SDL_GPUTextureRegion{ .texture = g.atlas_tex, .mip_level = 0, .layer = 0, .x = 0, .y = top, .z = 0, .w = atlas_w, .h = rows, .d = 1 };
c.SDL_UploadToGPUTexture(copy, &src, &dstregion, false);
c.SDL_EndGPUCopyPass(copy);
- g.atlas_dirty = false;
+ g.atlas_dirty_top = atlas_h;
+ g.atlas_dirty_bottom = 0;
+}
+
+test "the atlas's dirty rows hold every row a new glyph draws into, and a reset dirties them all" {
+ const font = c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len)).?;
+ defer c.ui_font_free(font);
+ var g = try textTestGui(font, 18);
+ defer font_allocator = std.heap.smp_allocator;
+ defer std.testing.allocator.free(g.atlas_stage);
+ defer g.glyphs.deinit();
+ defer g.words.deinit(std.testing.allocator);
+ // The texture as uploadAtlas leaves it, which starts undefined.
+ const texture = try std.testing.allocator.alloc(u8, atlas_w * atlas_h);
+ defer std.testing.allocator.free(texture);
+ @memset(texture, 0xa5);
+ var glyph: u32 = 0;
+ for (0..40) |frame| {
+ if (frame == 30) resetGlyphAtlas(&g); // a font change
+ // Plain glyphs, strips, taglines, grip glyphs and decorations.
+ for (0..25) |_| {
+ glyph += 1;
+ const span: u4 = @intCast(1 + glyph % 3);
+ _ = cachedGlyph(&g, .{
+ .face = 0,
+ .glyph = glyph,
+ .role = if (glyph % 4 == 0) .tagline else .body,
+ .decoration = .{ .bold = glyph % 2 == 0, .underline = if (glyph % 5 == 0) .curly else .off, .strikethrough = glyph % 11 == 0 },
+ .centered = glyph % 13 == 0,
+ .lead = @intCast(glyph % span),
+ .span = span,
+ }) orelse return error.AtlasFull;
+ }
+ for (0..atlas_h) |row| {
+ const stage = g.atlas_stage[row * atlas_w ..][0..atlas_w];
+ const uploaded = texture[row * atlas_w ..][0..atlas_w];
+ if (row >= g.atlas_dirty_top and row < g.atlas_dirty_bottom)
+ @memcpy(uploaded, stage)
+ else
+ try std.testing.expect(std.mem.eql(u8, stage, uploaded));
+ }
+ g.atlas_dirty_top = atlas_h;
+ g.atlas_dirty_bottom = 0;
+ }
+ try std.testing.expect(g.pen_y >= 2 * g.cell_h);
}
fn ensureVbuf(g: *Gui, cells: u32) !void {
@@ -6048,10 +8335,12 @@ fn ensureVbuf(g: *Gui, cells: u32) !void {
g.vbuf_cells = capacity;
}
-fn makePipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFormat) !*c.SDL_GPUGraphicsPipeline {
+/// A pipeline over cell instances: the cells' own (ui.frag, the atlas, no
+/// blending) or the decor's (decor.frag, blended like the overlay).
+fn makePipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFormat, frag: []const u8, samplers: u32, blend: c.SDL_GPUColorTargetBlendState) !*c.SDL_GPUGraphicsPipeline {
const vs = try makeShader(device, vert_spv, c.SDL_GPU_SHADERSTAGE_VERTEX, 0, 0);
defer c.SDL_ReleaseGPUShader(device, vs);
- const fs = try makeShader(device, frag_spv, c.SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 1);
+ const fs = try makeShader(device, frag, c.SDL_GPU_SHADERSTAGE_FRAGMENT, samplers, 1);
defer c.SDL_ReleaseGPUShader(device, fs);
var vbuf_desc = c.SDL_GPUVertexBufferDescription{
@@ -6068,8 +8357,9 @@ fn makePipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFormat)
.{ .location = 4, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "panel_x0") },
.{ .location = 5, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "present_x0") },
.{ .location = 6, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_UINT4, .offset = @offsetOf(CellInstance, "effect") },
+ .{ .location = 7, .buffer_slot = 0, .format = c.SDL_GPU_VERTEXELEMENTFORMAT_FLOAT4, .offset = @offsetOf(CellInstance, "clip_x0") },
};
- var col_desc = c.SDL_GPUColorTargetDescription{ .format = color_format, .blend_state = std.mem.zeroes(c.SDL_GPUColorTargetBlendState) };
+ var col_desc = c.SDL_GPUColorTargetDescription{ .format = color_format, .blend_state = blend };
var info = std.mem.zeroes(c.SDL_GPUGraphicsPipelineCreateInfo);
info.vertex_shader = vs;
@@ -6088,6 +8378,20 @@ fn makePipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFormat)
return c.SDL_CreateGPUGraphicsPipeline(device, &info) orelse error.GpuCreate;
}
+/// Premultiplied over: an opaque cell writes itself exactly, a see-through
+/// one only its ink.
+fn premultipliedBlend() c.SDL_GPUColorTargetBlendState {
+ var blend = std.mem.zeroes(c.SDL_GPUColorTargetBlendState);
+ blend.src_color_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE;
+ blend.dst_color_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+ blend.color_blend_op = c.SDL_GPU_BLENDOP_ADD;
+ blend.src_alpha_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE;
+ blend.dst_alpha_blendfactor = c.SDL_GPU_BLENDFACTOR_ONE_MINUS_SRC_ALPHA;
+ blend.alpha_blend_op = c.SDL_GPU_BLENDOP_ADD;
+ blend.enable_blend = true;
+ return blend;
+}
+
fn backgroundLayerBlend() c.SDL_GPUColorTargetBlendState {
var blend = std.mem.zeroes(c.SDL_GPUColorTargetBlendState);
blend.src_color_blendfactor = c.SDL_GPU_BLENDFACTOR_SRC_ALPHA;
@@ -6186,25 +8490,7 @@ fn makeImagePipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFor
return c.SDL_CreateGPUGraphicsPipeline(device, &info) orelse error.GpuCreate;
}
-fn makeCrtPipeline(device: *c.SDL_GPUDevice, color_format: c.SDL_GPUTextureFormat) !*c.SDL_GPUGraphicsPipeline {
- const vs = try makeShader(device, crt_vert_spv, c.SDL_GPU_SHADERSTAGE_VERTEX, 0, 0);
- defer c.SDL_ReleaseGPUShader(device, vs);
- const fs = try makeShader(device, crt_frag_spv, c.SDL_GPU_SHADERSTAGE_FRAGMENT, 1, 1);
- defer c.SDL_ReleaseGPUShader(device, fs);
-
- var col_desc = c.SDL_GPUColorTargetDescription{ .format = color_format, .blend_state = std.mem.zeroes(c.SDL_GPUColorTargetBlendState) };
- var info = std.mem.zeroes(c.SDL_GPUGraphicsPipelineCreateInfo);
- info.vertex_shader = vs;
- info.fragment_shader = fs;
- info.primitive_type = c.SDL_GPU_PRIMITIVETYPE_TRIANGLELIST;
- info.rasterizer_state.fill_mode = c.SDL_GPU_FILLMODE_FILL;
- info.rasterizer_state.cull_mode = c.SDL_GPU_CULLMODE_NONE;
- info.multisample_state.sample_count = c.SDL_GPU_SAMPLECOUNT_1;
- info.target_info = .{ .color_target_descriptions = &col_desc, .num_color_targets = 1 };
- return c.SDL_CreateGPUGraphicsPipeline(device, &info) orelse error.GpuCreate;
-}
-
-fn makeShader(device: *c.SDL_GPUDevice, code: []const u8, stage: c.SDL_GPUShaderStage, n_samplers: u32, n_uniform_buffers: u32) !*c.SDL_GPUShader {
+pub fn makeShader(device: *c.SDL_GPUDevice, code: []const u8, stage: c.SDL_GPUShaderStage, n_samplers: u32, n_uniform_buffers: u32) !*c.SDL_GPUShader {
var info = std.mem.zeroes(c.SDL_GPUShaderCreateInfo);
info.code = code.ptr;
info.code_size = code.len;
@@ -6330,21 +8616,31 @@ fn softPresentFrame(g: *Gui, cmd: *c.SDL_GPUCommandBuffer, target: *c.SDL_GPUTex
const fence = c.SDL_SubmitGPUCommandBufferAndAcquireFence(cmd) orelse return error.GpuSubmit;
defer c.SDL_ReleaseGPUFence(g.device, fence);
var fences = [_]*c.SDL_GPUFence{fence};
+ const probe_wait = monoNs();
if (!c.SDL_WaitForGPUFences(g.device, true, &fences, 1)) return error.GpuSubmit;
+ if (frame_probe) |probe| probe.zone(.gui_wait, probe_wait);
const mapped = c.SDL_MapGPUTransferBuffer(g.device, xfer, false) orelse return error.GpuMap;
defer c.SDL_UnmapGPUTransferBuffer(g.device, xfer);
const texture = try ensureSoftTexture(g, sw, sh);
const renderer = g.soft_renderer orelse return error.GpuCreate;
+ const probe_upload = monoNs();
+ defer if (frame_probe) |probe| probe.zone(.gui_upload, probe_upload);
if (!c.SDL_UpdateTexture(texture, null, mapped, @intCast(sw * bpp))) return error.GpuMap;
+ // PARDES_FRAMES_CAPTURE: every presented frame's pixels as they went
+ // out, and when, for a recording at the frames' own times (the
+ // samples of docs/next-anim.md). One write a frame; nothing else.
+ if (frame_capture_dir) |dir| captureSeries(dir, @as([*]const u8, @ptrCast(mapped))[0..size], sw, sh);
// The cell shader already produced premultiplied backgrounds with opaque
// foreground ink. Copy that alpha unchanged; never modulate the full frame.
_ = c.SDL_SetRenderDrawBlendMode(renderer, c.SDL_BLENDMODE_NONE);
- _ = c.SDL_SetRenderDrawColor(renderer, 0, 0, 0, if (g.transparent or g.surface_opacity) 0 else 255);
+ _ = c.SDL_SetRenderDrawColor(renderer, 0, 0, 0, if (g.surface_opacity) 0 else 255);
_ = c.SDL_RenderClear(renderer);
_ = c.SDL_RenderTexture(renderer, texture, null, null);
+ const probe_flip = monoNs();
_ = c.SDL_RenderPresent(renderer);
+ if (frame_probe) |probe| probe.zone(.gui_flip, probe_flip);
}
fn backgroundOpacity(percent: u8) f32 {
@@ -6361,7 +8657,30 @@ test "background opacity retains exact endpoints and percentage precision" {
}
}
-fn captureFrame(g: *Gui, gpa: std.mem.Allocator, cmd: *c.SDL_GPUCommandBuffer, target: *c.SDL_GPUTexture, sw: u32, sh: u32) !void {
+/// PARDES_TEST_LATENCY trace for an external driver, CLOCK_MONOTONIC ns:
+/// `R t` when stdin input is read, `F start fence submit` per captured frame
+/// (present entry, the GPU fence of that frame, and its submission: submit -
+/// start is the frame's CPU cost). Nothing is written without it.
+var latency_fd: c_int = -1;
+var frame_started_ns: u64 = 0;
+
+fn monoNs() u64 {
+ var ts: libc.timespec = undefined;
+ if (libc.clock_gettime(.MONOTONIC, &ts) != 0) return 0;
+ return @as(u64, @intCast(ts.sec)) * std.time.ns_per_s + @as(u64, @intCast(ts.nsec));
+}
+
+fn latencyNote(comptime fmt: []const u8, args: anytype) void {
+ if (latency_fd < 0) return;
+ var buf: [64]u8 = undefined;
+ const line = std.fmt.bufPrint(&buf, fmt, args) catch return;
+ _ = libc.write(latency_fd, line.ptr, line.len);
+}
+
+/// Writes the frame to latest.ppm in the capture directory, and a panel
+/// transition's frame `transition` to transition-<frame>.ppm too, so a test
+/// can hold one partway (test/gui_golden.py).
+fn captureFrame(g: *Gui, gpa: std.mem.Allocator, cmd: *c.SDL_GPUCommandBuffer, target: *c.SDL_GPUTexture, sw: u32, sh: u32, transition: ?u16) !void {
const size = c.SDL_CalculateGPUTextureFormatSize(g.swapchain_format, sw, sh, 1);
if (size == 0) {
_ = c.SDL_SubmitGPUCommandBuffer(cmd);
@@ -6384,19 +8703,54 @@ fn captureFrame(g: *Gui, gpa: std.mem.Allocator, cmd: *c.SDL_GPUCommandBuffer, t
c.SDL_DownloadFromGPUTexture(copy, &src, &dst);
c.SDL_EndGPUCopyPass(copy);
+ const submit_ns = monoNs();
const fence = c.SDL_SubmitGPUCommandBufferAndAcquireFence(cmd) orelse return error.GpuSubmit;
defer c.SDL_ReleaseGPUFence(g.device, fence);
var fences = [_]*c.SDL_GPUFence{fence};
if (!c.SDL_WaitForGPUFences(g.device, true, &fences, 1)) return error.GpuSubmit;
+ latencyNote("F {d} {d} {d}\n", .{ frame_started_ns, monoNs(), submit_ns });
const mapped = c.SDL_MapGPUTransferBuffer(g.device, xfer, false) orelse return error.GpuMap;
defer c.SDL_UnmapGPUTransferBuffer(g.device, xfer);
const pixels: [*]const u8 = @ptrCast(mapped);
- try writeCapturePpm(g, gpa, pixels[0..size], sw, sh);
+ try writeCapturePpm(g, gpa, pixels[0..size], sw, sh, "latest");
+ var name: [24]u8 = undefined;
+ // unreachable below: "transition-" or "frame-" and a u32 fit 24
+ if (transition) |frame| try writeCapturePpm(g, gpa, pixels[0..size], sw, sh, std.fmt.bufPrint(&name, "transition-{d}", .{frame}) catch unreachable);
+ if (g.capture_series) try writeCapturePpm(g, gpa, pixels[0..size], sw, sh, std.fmt.bufPrint(&name, "frame-{d:0>5}", .{g.captured}) catch unreachable);
+ g.captured +%= 1;
}
-fn writeCapturePpm(g: *Gui, gpa: std.mem.Allocator, pixels: []const u8, width: u32, height: u32) !void {
+/// A test window's state for a harness (test/gui_golden.py), in the
+/// capture directory's `status`: "<loop step> <frames captured> <idle>".
+/// Idle is 1 once the frame last captured is the one that stays: nothing
+/// owes a frame, nothing moves, nothing waits on a clock. A harness that
+/// sees a step past the one it acted on, idle, has its frame, however slow
+/// the machine is.
+var test_status_step: u64 = 0;
+fn writeTestStatus(g: *const Gui, core: *const pardes.Pardes, presented: bool) void {
+ test_status_step +%= 1;
if (g.capture_dir.len == 0) return;
+ const idle = presented and !core.needs_frame and !core.continuous() and core.nextWake() == null and
+ !g.glide.moving() and g.scroll_lag == 0 and g.scroll_delta == 0 and g.scroll_notch == 0;
+ var line_buf: [64]u8 = undefined;
+ // What keeps it busy, after: owes a frame, moves, waits, not shown.
+ const line = std.fmt.bufPrint(&line_buf, "{d} {d} {d} {d}{d}{d}{d}\n", .{ test_status_step, g.captured, @intFromBool(idle), @intFromBool(core.needs_frame), @intFromBool(core.continuous()), @intFromBool(core.nextWake() != null), @intFromBool(!presented) }) catch return;
+ var tmp_buf: [4096]u8 = undefined;
+ var final_buf: [4096]u8 = undefined;
+ const tmp_path = std.fmt.bufPrintSentinel(&tmp_buf, "{s}/status.tmp", .{g.capture_dir}, 0) catch return;
+ const final_path = std.fmt.bufPrintSentinel(&final_buf, "{s}/status", .{g.capture_dir}, 0) catch return;
+ const fd = libc.open(tmp_path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(libc.mode_t, 0o644));
+ if (fd < 0) return;
+ _ = libc.write(fd, line.ptr, line.len);
+ _ = libc.close(fd);
+ _ = libc.rename(tmp_path, final_path);
+}
+
+fn writeCapturePpm(g: *Gui, gpa: std.mem.Allocator, pixels: []const u8, width: u32, height: u32, name: []const u8) !void {
+ // A latency trace times frames, and an 8 MB file write per frame would
+ // stall the loop it is timing.
+ if (g.capture_dir.len == 0 or latency_fd >= 0) return;
const bpp = c.SDL_GPUTextureFormatTexelBlockSize(g.swapchain_format);
if (bpp != 4) return error.UnsupportedCaptureFormat;
const bgr = switch (g.swapchain_format) {
@@ -6407,8 +8761,8 @@ fn writeCapturePpm(g: *Gui, gpa: std.mem.Allocator, pixels: []const u8, width: u
var tmp_buf: [4096]u8 = undefined;
var final_buf: [4096]u8 = undefined;
- const tmp_path = std.fmt.bufPrintSentinel(&tmp_buf, "{s}/latest.ppm.tmp", .{g.capture_dir}, 0) catch return error.CapturePathTooLong;
- const final_path = std.fmt.bufPrintSentinel(&final_buf, "{s}/latest.ppm", .{g.capture_dir}, 0) catch return error.CapturePathTooLong;
+ const tmp_path = std.fmt.bufPrintSentinel(&tmp_buf, "{s}/{s}.ppm.tmp", .{ g.capture_dir, name }, 0) catch return error.CapturePathTooLong;
+ const final_path = std.fmt.bufPrintSentinel(&final_buf, "{s}/{s}.ppm", .{ g.capture_dir, name }, 0) catch return error.CapturePathTooLong;
const fd = libc.open(tmp_path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(libc.mode_t, 0o644));
if (fd < 0) return error.CaptureWriteFailed;
@@ -6434,151 +8788,1868 @@ fn writeCapturePpm(g: *Gui, gpa: std.mem.Allocator, pixels: []const u8, width: u
if (libc.rename(tmp_path, final_path) != 0) return error.CaptureWriteFailed;
}
-fn addCursorBar(
- builder: *OverlayBuilder,
- x: u16,
- y: u16,
- bar: bool,
- visual_height: f32,
- layout: CellLayout,
- rgb: [3]u8,
-) void {
- if (!bar) return;
- const previous_ink = builder.ink;
- builder.ink = true;
- defer builder.ink = previous_ink;
- const x0 = layout.x_off + @as(f32, @floatFromInt(x)) * layout.w;
- const height = std.math.clamp(visual_height, 1.0, layout.h);
- const y0 = layout.y_off + @as(f32, @floatFromInt(y)) * layout.h +
- @as(f32, @floatFromInt(taglineBandOffset(y, builder.win_h, @intFromFloat(layout.h), @intFromFloat(height), true)));
- builder.addRect(
- x0,
- y0,
- x0 + @max(1.0, layout.w / 8.0),
- y0 + height,
- .{
- .r = @as(f32, @floatFromInt(rgb[0])) / 255.0,
- .g = @as(f32, @floatFromInt(rgb[1])) / 255.0,
- .b = @as(f32, @floatFromInt(rgb[2])) / 255.0,
- .a = 1.0,
+/// One flat, hard-edged rectangle of decor, in window pixels: clipped to the
+/// window and dropped when empty, as the triangle overlay drew it, and moved
+/// by `track` as its pane's cells are.
+fn addDecor(g: *Gui, gpa: std.mem.Allocator, x0_in: f32, y0_in: f32, x1_in: f32, y1_in: f32, rgb: [3]u8, alpha: f32, track: ?pardes.animation.Track, win_w: f32, win_h: f32) !void {
+ const x0 = std.math.clamp(@min(x0_in, x1_in), 0.0, win_w);
+ const x1 = std.math.clamp(@max(x0_in, x1_in), 0.0, win_w);
+ const y0 = std.math.clamp(@min(y0_in, y1_in), 0.0, win_h);
+ const y1 = std.math.clamp(@max(y0_in, y1_in), 0.0, win_h);
+ if (x1 <= x0 or y1 <= y0) return;
+ // decor.frag.glsl reads the colour from the ground and the coverage
+ // from the ink's red.
+ var instance: CellInstance = .{
+ .x0 = (x0 / win_w) * 2.0 - 1.0,
+ .y0 = 1.0 - (y0 / win_h) * 2.0,
+ .x1 = (x1 / win_w) * 2.0 - 1.0,
+ .y1 = 1.0 - (y1 / win_h) * 2.0,
+ .u0 = 0,
+ .v0 = 0,
+ .u1 = 0,
+ .v1 = 0,
+ .fr = alpha,
+ .fg = 0,
+ .fb = 0,
+ .br = @as(f32, @floatFromInt(rgb[0])) / 255.0,
+ .bg = @as(f32, @floatFromInt(rgb[1])) / 255.0,
+ .bb = @as(f32, @floatFromInt(rgb[2])) / 255.0,
+ };
+ setTransitionFields(&instance, track, fixedCellLayout(g), win_w, win_h, 0);
+ try g.decor.append(gpa, instance);
+}
+
+/// A checker (decor.frag.glsl): squares of `px` window pixels in `a` and
+/// `b` from the quad's corner (lapis's scroll track); `stripes`, bands of
+/// `px` across it instead (lapis's focused title bar), `a` first.
+fn addChecker(g: *Gui, gpa: std.mem.Allocator, x0: f32, y0: f32, x1: f32, y1: f32, a: [3]u8, b: [3]u8, px: f32, track: ?pardes.animation.Track, win_w: f32, win_h: f32) !void {
+ return addPattern(g, gpa, x0, y0, x1, y1, a, b, px, false, track, win_w, win_h);
+}
+
+fn addPattern(g: *Gui, gpa: std.mem.Allocator, x0: f32, y0: f32, x1: f32, y1: f32, a: [3]u8, b: [3]u8, px: f32, stripes: bool, track: ?pardes.animation.Track, win_w: f32, win_h: f32) !void {
+ const first = g.decor.items.len;
+ try addDecor(g, gpa, x0, y0, x1, y1, a, 1, track, win_w, win_h);
+ if (g.decor.items.len == first) return;
+ const instance = &g.decor.items[first];
+ instance.u0 = px;
+ instance.u1 = px;
+ instance.v0 = if (stripes) 1 else 0;
+ instance.v1 = if (stripes) 1 else 0;
+ instance.fr = @as(f32, @floatFromInt(b[0])) / 255.0;
+ instance.fg = @as(f32, @floatFromInt(b[1])) / 255.0;
+ instance.fb = @as(f32, @floatFromInt(b[2])) / 255.0;
+ instance.effect |= checker_bit;
+}
+
+/// How a lift of 0 to 1 stands off the page: the shadow's blur and offset
+/// in cell heights, and its darkest, where it leaves the caster's edge.
+/// Within §8.2's budget: sigma 0.4-0.8 cell, at most 30% darker at the edge.
+const Shadow = struct {
+ // A key light above: the drop is most of the blur, so the shadow hangs
+ // below and to the right and barely reaches over the caster's top.
+ const sigma: f32 = 0.42;
+ const drop: f32 = 0.34;
+ const side: f32 = 0.1;
+ const strength: f32 = 0.42;
+};
+
+/// A soft rectangle around `caster` (window pixels), blurred by `sigma`
+/// and moved by (dx, dy): black is a shadow, a light colour a rim or a
+/// glow. The caster's own rectangle is left alone, and `track` moves it all
+/// as its caster moves.
+fn addSoft(g: *Gui, gpa: std.mem.Allocator, caster: [4]f32, sigma_in: f32, dx: f32, dy: f32, strength: f32, rgb: [3]u8, track: ?pardes.animation.Track, win_w: f32, win_h: f32) !void {
+ if (strength <= 0.002) return;
+ const sigma = @max(0.5, sigma_in);
+ const x0 = caster[0] + dx - 3 * sigma;
+ const y0 = caster[1] + dy - 3 * sigma;
+ const x1 = caster[2] + dx + 3 * sigma;
+ const y1 = caster[3] + dy + 3 * sigma;
+ const w = x1 - x0;
+ const ht = y1 - y0;
+ if (w <= 0 or ht <= 0) return;
+ // In the quad's own 0..1 space (decor.frag.glsl): sigma per axis, the
+ // caster's offset from its shadow, the strength.
+ var instance: CellInstance = .{
+ .x0 = (x0 / win_w) * 2.0 - 1.0,
+ .y0 = 1.0 - (y0 / win_h) * 2.0,
+ .x1 = (x1 / win_w) * 2.0 - 1.0,
+ .y1 = 1.0 - (y1 / win_h) * 2.0,
+ .u0 = sigma / w,
+ .v0 = sigma / ht,
+ .u1 = sigma / w,
+ .v1 = sigma / ht,
+ .fr = strength,
+ .fg = dx / w,
+ .fb = dy / ht,
+ .br = @as(f32, @floatFromInt(rgb[0])) / 255,
+ .bg = @as(f32, @floatFromInt(rgb[1])) / 255,
+ .bb = @as(f32, @floatFromInt(rgb[2])) / 255,
+ };
+ setTransitionFields(&instance, track, fixedCellLayout(g), win_w, win_h, 0);
+ instance.effect |= soft_shadow_bit;
+ try g.decor.append(gpa, instance);
+}
+
+/// How far each lift style may go on this theme without its text falling
+/// below min(its contrast, 4.5): a shadow darkens, the others lighten.
+const LiftCeilings = struct {
+ shadow: f32,
+ white: f32,
+ /// A rim is light on a dark page and shade on a light one, where light
+ /// would not show.
+ rim: [3]u8,
+
+ /// Over the text on the page, and over a selection's text on its own
+ /// ground: the lower of the two.
+ fn of(chrome: *const pardes.Chrome) LiftCeilings {
+ const fg = chrome.fg orelse fg_default;
+ const bg = chrome.page orelse bg_default;
+ return .{
+ .shadow = @min(shadowCeiling(fg, bg), shadowCeiling(chrome.sel_fg, chrome.sel_bg)),
+ .white = @min(lightenCeiling(fg, bg, .{ 255, 255, 255 }), lightenCeiling(chrome.sel_fg, chrome.sel_bg, .{ 255, 255, 255 })),
+ .rim = if (luminance(bg) < 0.18) .{ 255, 255, 255 } else .{ 0, 0, 0 },
+ };
+ }
+};
+
+/// What stands a lifted part off the page, `lift` 0 to 1 (a pane's spring,
+/// a notice's 1), in the style chosen: a soft shadow, or a rim along the
+/// top of the focused pane's tag rows (`rim_edge`, a pane's only:
+/// never a notice's).
+fn addLift(g: *Gui, gpa: std.mem.Allocator, style: pardes.config.Runtime.LiftStyle, ceilings: LiftCeilings, caster: [4]f32, rim_edge: ?[3]f32, bodies: []const [4]f32, lift: f32, track: ?pardes.animation.Track, win_w: f32, win_h: f32) !void {
+ if (lift <= 0.001) return;
+ const h: f32 = @floatFromInt(g.cell_h);
+ // The core sends `auto` already resolved (draw.liftStyle).
+ const shadow = switch (style) {
+ .off => return,
+ .shadow, .auto => true,
+ .rim => false,
+ };
+ if (shadow) {
+ // Nothing of a shadow may touch a focus indicator (docs/effects.md):
+ // it falls on pane bodies and rails, never a tag, a grip or a header.
+ const first = g.decor.items.len;
+ try addSoft(g, gpa, caster, Shadow.sigma * h * lift, Shadow.side * h * lift, Shadow.drop * h * lift, @min(Shadow.strength * lift, ceilings.shadow), .{ 0, 0, 0 }, track, win_w, win_h);
+ try clipToBodies(g, gpa, first, bodies);
+ }
+ // A hairline just above the focused tag rows, never on them: it adds to
+ // the indicator without changing its colour.
+ if (style == .rim) if (rim_edge) |edge| {
+ const light = ceilings.rim[0] == 255;
+ const alpha = @min(Lift.rim * lift, if (light) ceilings.white else ceilings.shadow);
+ try addDecor(g, gpa, edge[0], edge[2] - dp(1), edge[1], edge[2], ceilings.rim, alpha, track, win_w, win_h);
+ };
+}
+
+/// A rim's strength, in the §8.2 budget for coloured light.
+const Lift = struct {
+ const rim: f32 = 0.35;
+};
+
+/// A body region in window pixels.
+fn bodyPixels(region: pardes.Region, layout: CellLayout) [4]f32 {
+ return .{
+ @as(f32, @floatFromInt(region.rect.x)) * layout.w,
+ @as(f32, @floatFromInt(region.rect.y)) * layout.h,
+ @as(f32, @floatFromInt(region.rect.x + region.rect.w)) * layout.w,
+ @as(f32, @floatFromInt(region.rect.y + region.rect.h)) * layout.h,
+ };
+}
+
+/// Replaces the decor from `first` on with a copy per pane body it reaches,
+/// each clipped to that body (and to what a vertical transition already
+/// clipped it to): the lift then never reaches a tag, a grip or a header.
+fn clipToBodies(g: *Gui, gpa: std.mem.Allocator, first: usize, bodies: []const [4]f32) !void {
+ const added = g.decor.items.len - first;
+ if (added == 0) return;
+ var own: [8]CellInstance = undefined;
+ const n = @min(added, own.len);
+ @memcpy(own[0..n], g.decor.items[first..][0..n]);
+ g.decor.shrinkRetainingCapacity(first);
+ for (own[0..n]) |instance| for (bodies) |body| {
+ var copy = instance;
+ const vertical = copy.clip_x1 >= copy.clip_x0;
+ copy.clip_x0 = if (vertical) @max(copy.clip_x0, body[0]) else body[0];
+ copy.clip_y0 = if (vertical) @max(copy.clip_y0, body[1]) else body[1];
+ copy.clip_x1 = if (vertical) @min(copy.clip_x1, body[2]) else body[2];
+ copy.clip_y1 = if (vertical) @min(copy.clip_y1, body[3]) else body[3];
+ if (copy.clip_x1 <= copy.clip_x0 or copy.clip_y1 <= copy.clip_y0) continue;
+ try g.decor.append(gpa, copy);
+ };
+}
+
+/// Like shadowCeiling for a light colour laid over at `a` (sRGB blend, as
+/// the decor pipeline blends a colour that is not black): the largest `a`
+/// that keeps text and page apart by min(their contrast, 4.5).
+fn lightenCeiling(fg: [3]u8, bg: [3]u8, rgb: [3]u8) f32 {
+ const contrast = pardes.colors.contrast;
+ const blend = struct {
+ fn of(under: [3]u8, over: [3]u8, a: f32) [3]u8 {
+ var out: [3]u8 = undefined;
+ for (&out, under, over) |*o, x, y| o.* = @intFromFloat(@round(@as(f32, @floatFromInt(x)) * (1 - a) + @as(f32, @floatFromInt(y)) * a));
+ return out;
+ }
+ }.of;
+ const target = @min(contrast(fg, bg), 4.5);
+ var lo: f32 = 0;
+ var hi: f32 = 1;
+ for (0..24) |_| {
+ const mid = (lo + hi) / 2;
+ if (contrast(blend(fg, rgb, mid), blend(bg, rgb, mid)) >= target - 1e-3) lo = mid else hi = mid;
+ }
+ return lo;
+}
+
+const luminance = pardes.colors.relativeLuminance;
+
+/// How dark a shadow may make the page and its text, both together, before
+/// the pair drops below its own contrast or 4.5, whichever is lower (§8.2):
+/// darkening in linear light by k leaves (k L1 + .05) / (k L2 + .05).
+fn shadowCeiling(fg: [3]u8, bg: [3]u8) f32 {
+ const a = luminance(fg);
+ const b = luminance(bg);
+ const light = @max(a, b);
+ const dark = @min(a, b);
+ const target = @min((light + 0.05) / (dark + 0.05), 4.5);
+ const room = light - target * dark;
+ if (room <= 0) return 0;
+ return std.math.clamp(1 - 0.05 * (target - 1) / room, 0, 1);
+}
+
+test "a rim never lightens a native theme's text below its contrast or 4.5" {
+ for (pardes.themes) |theme| {
+ const fg = theme.fg orelse fg_default;
+ const bg = theme.bg orelse bg_default;
+ for ([_][3]u8{.{ 255, 255, 255 }}) |light| {
+ const a = @min(Lift.rim, lightenCeiling(fg, bg, light));
+ const blend = struct {
+ fn of(under: [3]u8, over: [3]u8, t: f32) [3]u8 {
+ var out: [3]u8 = undefined;
+ for (&out, under, over) |*o, x, y| o.* = @intFromFloat(@round(@as(f32, @floatFromInt(x)) * (1 - t) + @as(f32, @floatFromInt(y)) * t));
+ return out;
+ }
+ }.of;
+ const ratio = pardes.colors.contrast;
+ try std.testing.expect(ratio(blend(fg, light, a), blend(bg, light, a)) >= @min(ratio(fg, bg), 4.5) - 2e-3);
+ }
+ }
+}
+
+test "a lift never touches a tag, a grip or a header, on a light theme or a dark one" {
+ const gpa = std.testing.allocator;
+ for ([_][]const u8{ "forge", "daybreak" }) |name| {
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ core.update(.{ .resize = .{ .cols = 80, .rows = 24, .row_metrics = .{ .body_w = 10, .body_h = 20, .tagline_w = 6, .tagline_h = 12 } } });
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ var line: [64]u8 = undefined;
+ try std.testing.expect(core.executeBuiltinLine(0, try std.fmt.bufPrint(&line, "Theme {s}", .{name})));
+ for (0..40) |_| core.update(.tick);
+ for (std.enums.values(pardes.config.Runtime.LiftStyle)) |style| {
+ core.settings.lift = style;
+ try std.testing.expect(core.executeBuiltinLine(0, "Msg a floating notice"));
+ core.advance(core.now_ns + 2 * std.time.ns_per_s);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ core.advance(core.now_ns + 2 * std.time.ns_per_s);
+ const settled = try core.render(core.scratch.allocator());
+ _ = s;
+ // The focus indicator itself: the focused pane's tag is not the
+ // others' colour, whatever the lift.
+ var active: ?[3]u8 = null;
+ var other: ?[3]u8 = null;
+ for (settled.tagLayers()) |layer| if (layer.rows != 0 and layer.kind == .pane) {
+ if (layer.id == core.active) active = layer.bg else other = layer.bg;
+ };
+ try std.testing.expect(!std.mem.eql(u8, &active.?, &other.?));
+ var g: Gui = undefined;
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, settled, &groups, fixedCellLayout(&g), 800, 480, true);
+ var lifted: usize = 0;
+ for (g.decor.items) |item| {
+ if (item.clip_x1 < item.clip_x0) continue;
+ lifted += 1;
+ // Inside a body or a rail, all of it.
+ const inside = for (settled.regionList()) |region| {
+ if (region.kind != .body and region.kind != .rail) continue;
+ const r = bodyPixels(region, fixedCellLayout(&g));
+ if (item.clip_x0 >= r[0] and item.clip_y0 >= r[1] and item.clip_x1 <= r[2] and item.clip_y1 <= r[3]) break true;
+ } else false;
+ try std.testing.expect(inside);
+ }
+ const light_page = std.mem.eql(u8, name, "daybreak");
+ try std.testing.expectEqual(style == .shadow or (style == .auto and light_page), lifted != 0);
+ // A rim is one hairline, just above the focused pane's tag row.
+ var rims: usize = 0;
+ for (g.decor.items) |item| {
+ if (item.clip_x1 >= item.clip_x0) continue;
+ const top = (1 - item.y0) / 2 * 480;
+ const height = (item.y0 - item.y1) / 2 * 480;
+ const on_active_tag = for (settled.regionList()) |region| {
+ if (region.kind == .tag and region.owner == core.active and @abs(top + 1 - @as(f32, @floatFromInt(region.rect.y)) * 20) < 0.01 and @abs(height - 1) < 0.01) break true;
+ } else false;
+ // Not the rule under a column bar, which may run there too.
+ rims += @intFromBool(on_active_tag and item.fr < 1);
+ }
+ try std.testing.expectEqual(@as(usize, @intFromBool(style == .rim)), rims);
+ }
+ }
+}
+
+test "a shadow never darkens a native theme's text below its contrast or 4.5" {
+ var shaded: usize = 0;
+ for (pardes.themes) |theme| {
+ const fg = theme.fg orelse fg_default;
+ const bg = theme.bg orelse bg_default;
+ const ceiling = shadowCeiling(fg, bg);
+ const k = 1 - @min(Shadow.strength, ceiling);
+ const light = @max(luminance(fg), luminance(bg));
+ const dark = @min(luminance(fg), luminance(bg));
+ const before = (light + 0.05) / (dark + 0.05);
+ const after = (k * light + 0.05) / (k * dark + 0.05);
+ try std.testing.expect(after >= @min(before, 4.5) - 1e-3);
+ shaded += @intFromBool(ceiling > 0.05);
+ }
+ // And most themes have room for one.
+ try std.testing.expect(shaded * 2 > pardes.themes.len);
+}
+
+/// The frame's decor, group by group (docs/render-pipeline.md §3.4), all of it
+/// read from the regions and the palette: the page's rules and the still
+/// panes' rails, rules and grip marks in tier 0, a moving or closing pane's
+/// in its track's group, notice rules in tier 4, bar cursors in tier 5.
+fn buildDecor(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, groups: *Groups, layout: CellLayout, win_w: f32, win_h: f32, cursors_shown: bool) !void {
+ g.decor.clearRetainingCapacity();
+ const chrome = &surface.chrome;
+ const regions = surface.regionList();
+ const ceilings = LiftCeilings.of(chrome);
+ var current_buf: [pardes.MAX_PANES][4]f32 = undefined;
+ var ncurrent: usize = 0;
+ for (regions) |part| if ((part.kind == .body or part.kind == .rail) and ncurrent < current_buf.len) {
+ current_buf[ncurrent] = bodyPixels(part, layout);
+ ncurrent += 1;
+ };
+ const current_bodies = current_buf[0..ncurrent];
+ const lift_style = std.enums.fromInt(pardes.config.Runtime.LiftStyle, chrome.lift_style) orelse .off;
+ const notice_lift = for (regions) |region| {
+ if (region.kind == .notice) break region.lift;
+ } else 0;
+ for (groups.items[0..groups.len], 0..) |*group, index| {
+ group.decor_start = @intCast(g.decor.items.len);
+ defer group.decor_count = @as(u32, @intCast(g.decor.items.len)) - group.decor_start;
+ // Under the cells: a theme's tag plaques, this group's panes' (and
+ // the column and workspace tags with the still ones).
+ if (index <= groups.tracks) {
+ const closing = if (group.track) |active| active.phase == .closing else false;
+ try tagPlaques(g, gpa, if (closing) surface.previous_regions else regions, groups, index, chrome, layout, win_w, win_h, group.track);
+ }
+ group.under_count = @as(u32, @intCast(g.decor.items.len)) - group.decor_start;
+ // The grips' buttons before any rule: the rules over their rows cut
+ // them, and the band round them never covers a rule.
+ if (index <= groups.tracks) {
+ const closing = if (group.track) |active| active.phase == .closing else false;
+ try gripDecor(g, gpa, if (closing) surface.previous_regions else regions, if (closing) surface.previous_cells else surface.cells, groups, index, chrome, layout, surface.cols, surface.rows, win_w, win_h, group.track);
+ }
+ if (index == 0) {
+ const top = for (regions) |region| {
+ if (region.kind == .workspace_tag) break region.rect.h;
+ } else 0;
+ // The workspace tag is ruled off from the tags right under it.
+ const tag_under = for (regions) |region| switch (region.kind) {
+ .grip, .tag, .column_grip, .column_tag => if (region.rect.y == top) break true,
+ else => {},
+ } else false;
+ // As wide as the other rules, where the tagline leaves the room.
+ const height: u32 = @intFromFloat(@max(1, @min(rulePx(chrome), @as(f32, @floatFromInt((g.cell_h -| g.tagline_height) * 2)))));
+ if (top != 0 and top < surface.rows and tag_under and height != 0) {
+ const y0: f32 = @floatFromInt(top * g.cell_h - height / 2);
+ try addDecor(g, gpa, 0, y0, win_w, y0 + @as(f32, @floatFromInt(height)), chrome.topbar_rule, 1, null, win_w, win_h);
+ }
+ // The column bar is ruled off from the panes under it.
+ for (regions) |bar| {
+ if (bar.kind != .column_grip) continue;
+ const y = @as(f32, @floatFromInt(bar.rect.y + bar.rect.h)) * layout.h;
+ try addDecor(g, gpa, 0, y - rulePx(chrome), win_w, y, chrome.border, 1, null, win_w, win_h);
+ break;
+ }
+ // A tag on the last row runs on through the pixels under the grid.
+ const grid_bottom = @as(f32, @floatFromInt(surface.rows)) * layout.h;
+ const tag_last = for (regions) |region| switch (region.kind) {
+ .grip, .tag, .column_grip, .column_tag, .workspace_tag => if (region.rect.h != 0 and region.rect.y + region.rect.h == surface.rows) break true,
+ else => {},
+ } else false;
+ if (grid_bottom < win_h and tag_last) try addDecor(g, gpa, 0, grid_bottom, win_w, win_h, chrome.tag_bg, 1, null, win_w, win_h);
+ }
+ if (index <= groups.tracks) {
+ const track = group.track;
+ // A closing pane is gone: its chrome is the last frame's.
+ const closing = if (track) |active| active.phase == .closing else false;
+ const placed = if (closing) surface.previous_regions else regions;
+ // Where a lift may fall: pane bodies, never tags (addLift).
+ var body_buf: [pardes.MAX_PANES][4]f32 = undefined;
+ var nbodies: usize = 0;
+ for (placed) |part| if ((part.kind == .body or part.kind == .rail) and nbodies < body_buf.len) {
+ body_buf[nbodies] = bodyPixels(part, layout);
+ nbodies += 1;
+ };
+ const bodies = body_buf[0..nbodies];
+ const ticks: []const pardes.RailTick = if (closing) &.{} else surface.rail_ticks[0..surface.nrail_ticks];
+ try paneDecor(g, gpa, placed, ticks, groups, index, chrome, layout, surface.cols, surface.rows, win_w, win_h, track);
+ // G9, while nothing moves: a halo round the body's selection.
+ if (index == 0 and groups.tracks == 0 and chrome.fx & 1 != 0) try glowBlocks(g, gpa, surface, .selection, layout, win_w, win_h);
+ // G11: a glow under the word a look-hover would open.
+ if (index == 0 and groups.tracks == 0 and chrome.fx & 2 != 0) try glowBlocks(g, gpa, surface, .hover, layout, win_w, win_h);
+ // G14: what changed glows, while nothing moves.
+ // G12: the bodies' edges shaded, a pane's in its own group.
+ if (chrome.fx & 4 != 0) try occlusion(g, gpa, placed, groups, index, surface, ceilings, layout, win_w, win_h, track);
+ // A single spine runs down each column, through every tag and body.
+ if (index == 0) for (regions) |column| {
+ if (column.kind != .column) continue;
+ const x = @as(f32, @floatFromInt(column.rect.x)) * layout.w;
+ const y0 = @as(f32, @floatFromInt(column.rect.y)) * layout.h;
+ const grid_y1 = @as(f32, @floatFromInt(surface.rows)) * layout.h;
+ const y1 = if (win_h - grid_y1 < layout.h) @max(grid_y1, win_h) else grid_y1;
+ // None at the window's edge: nothing to rule apart there.
+ if (column.rect.x == 0) continue;
+ if (y1 > y0) try addDecor(g, gpa, x, y0, x + rulePx(chrome), y1, chrome.border, 1, null, win_w, win_h);
+ };
+ // Cast last in the group, over its cells, images and chrome: a
+ // lifted pane's shadow darkens its neighbours' rails and rules
+ // as it darkens their text, and never the pane itself.
+ for (placed) |grip| {
+ if (grip.kind != .grip or grip.lift <= 0.001 or groupOf(groups, grip.serial) != index) continue;
+ var box: [4]f32 = .{ @as(f32, @floatFromInt(grip.rect.x)) * layout.w, @as(f32, @floatFromInt(grip.rect.y)) * layout.h, 0, @as(f32, @floatFromInt(grip.rect.y + grip.rect.h)) * layout.h };
+ box[2] = box[0];
+ for (placed) |part| {
+ if (part.owner != grip.owner or (part.kind != .tag and part.kind != .rail and part.kind != .body)) continue;
+ box[1] = @min(box[1], @as(f32, @floatFromInt(part.rect.y)) * layout.h);
+ box[2] = @max(box[2], @as(f32, @floatFromInt(part.rect.x + part.rect.w)) * layout.w);
+ box[3] = @max(box[3], @as(f32, @floatFromInt(part.rect.y + part.rect.h)) * layout.h);
+ }
+ // The top edge of its tag rows, for a rim: x0, x1, y.
+ const rim_edge: ?[3]f32 = for (placed) |part| {
+ if (part.owner == grip.owner and part.kind == .tag) break .{ @as(f32, @floatFromInt(grip.rect.x)) * layout.w, @as(f32, @floatFromInt(part.rect.x + part.rect.w)) * layout.w, @as(f32, @floatFromInt(part.rect.y)) * layout.h };
+ } else null;
+ try addLift(g, gpa, lift_style, ceilings, box, rim_edge, bodies, grip.lift, track, win_w, win_h);
+ }
+ // G7: a pane on the move stands off the page, rising as it sets
+ // out and settling as it lands, its shadow on the other panes'
+ // bodies only (never a tag, a grip or its own text), moving
+ // with it.
+ if (track) |active| if (active.phase != .closing and (active.effect == .slide or active.effect == .zoom or active.effect == .vertical)) {
+ const steps: f32 = @floatFromInt(@max(1, active.frames() -| 1));
+ const u = std.math.clamp(@as(f32, @floatFromInt(active.frame)) / steps, 0, 1);
+ const lift = @sin(std.math.pi * u);
+ var box: [4]f32 = .{ std.math.inf(f32), std.math.inf(f32), -std.math.inf(f32), -std.math.inf(f32) };
+ var others: [pardes.MAX_PANES][4]f32 = undefined;
+ var nothers: usize = 0;
+ for (placed) |part| {
+ if (part.kind != .tag and part.kind != .rail and part.kind != .body and part.kind != .grip) continue;
+ const r = bodyPixels(part, layout);
+ if (part.owner == active.pane) {
+ box = .{ @min(box[0], r[0]), @min(box[1], r[1]), @max(box[2], r[2]), @max(box[3], r[3]) };
+ } else if ((part.kind == .body or part.kind == .rail) and nothers < others.len) {
+ others[nothers] = r;
+ nothers += 1;
+ }
+ }
+ if (box[2] > box[0] and lift > 0.01) {
+ const h: f32 = @floatFromInt(g.cell_h);
+ const first = g.decor.items.len;
+ try addSoft(g, gpa, box, Shadow.sigma * h * lift, Shadow.side * h * lift, Shadow.drop * h * lift, @min(Shadow.strength * lift, ceilings.shadow), .{ 0, 0, 0 }, track, win_w, win_h);
+ try clipToBodies(g, gpa, first, others[0..nothers]);
+ }
+ };
+ }
+ // A notice chip is tagline hung over the body's top rows, so it is
+ // ruled off from the text beneath it the way a tag is: the same
+ // colour and thickness along its bottom, running to the window's
+ // edge when it does, fading up and dissolving with its band.
+ // A notice floats: its shadow first, then every rule.
+ for (surface.tagLayers()) |*layer| {
+ if (layer.rows == 0 or layer.kind != .notice or noticeGroup(groups, layer) != index) continue;
+ const x = @as(f32, @floatFromInt(layer.viewport.x)) * layout.w;
+ const top = (@as(f32, @floatFromInt(layer.viewport.y)) + layer.slide) * layout.h;
+ const track = groups.items[groupAt(groups, layer.viewport.x, layer.viewport.y)].track;
+ try addLift(g, gpa, lift_style, ceilings, .{ x, top, x + @as(f32, @floatFromInt(layer.viewport.w)) * layout.w, top + layout.h }, null, current_bodies, notice_lift * layer.fade, track, win_w, win_h);
+ }
+ for (surface.tagLayers()) |*layer| {
+ if (layer.rows == 0 or layer.kind != .notice or noticeGroup(groups, layer) != index) continue;
+ const x0 = @as(f32, @floatFromInt(layer.viewport.x)) * layout.w;
+ const x1 = x0 + @as(f32, @floatFromInt(layer.viewport.w)) * layout.w;
+ const rule_x1 = if (win_w - x1 < layout.w) @max(x1, win_w) else x1;
+ const top = @as(f32, @floatFromInt(layer.viewport.y)) * layout.h;
+ // A band still falling into place is cut at its row's top; its
+ // rule comes with it, and shows only once it is below that cut.
+ const rule_y = top + (1 + layer.slide) * layout.h;
+ if (rule_y - dp(1) < top) continue;
+ const track = groups.items[groupAt(groups, layer.viewport.x, layer.viewport.y)].track;
+ try addDecor(g, gpa, x0, rule_y - dp(1), rule_x1, rule_y, chrome.border, layer.fade, track, win_w, win_h);
+ }
+ if (index == groups.ink and cursors_shown) try cursorDecor(g, gpa, surface, layout, win_w, win_h);
+ }
+}
+
+/// Each pane's rule between its tag and body, and its scroll rail: a page
+/// coloured gutter with a thin track and its thumb, running down through the
+/// pixels past the last whole row. Only the panes of group `index`.
+fn paneDecor(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, ticks: []const pardes.RailTick, groups: *const Groups, index: usize, chrome: *const pardes.Chrome, layout: CellLayout, cols: u16, rows: u16, win_w: f32, win_h: f32, track: ?pardes.animation.Track) !void {
+ const page = chrome.page orelse bg_default;
+ for (regions) |rail| {
+ if (rail.kind != .rail or rail.rect.h == 0 or groupOf(groups, rail.serial) != index) continue;
+ const tag = for (regions) |region| {
+ if (region.kind == .tag and region.owner == rail.owner) break region;
+ } else continue;
+ if (@as(u32, tag.rect.x) + tag.rect.w > cols or @as(u32, tag.rect.y) + tag.rect.h > rows or
+ @as(u32, rail.rect.y) + rail.rect.h > rows) continue;
+ const x0 = @as(f32, @floatFromInt(rail.rect.x)) * layout.w;
+ const x1 = @as(f32, @floatFromInt(tag.rect.x + tag.rect.w)) * layout.w;
+ // Like the band above it, the rule of a pane at the right edge runs
+ // on through the pixels past the last whole cell. Under a tag on
+ // top, over one below its body.
+ const rule_x1 = if (win_w - x1 < layout.w) @max(x1, win_w) else x1;
+ const tag_bottom = tag.rect.y > rail.rect.y;
+ const rule_y = @as(f32, @floatFromInt(if (tag_bottom) tag.rect.y else tag.rect.y + tag.rect.h)) * layout.h;
+ try addDecor(g, gpa, x0, if (tag_bottom) rule_y else rule_y - dp(1), rule_x1, if (tag_bottom) rule_y + dp(1) else rule_y, chrome.tag_rule orelse mixRgb(chrome.tag_bg, page), 1, track, win_w, win_h);
+ // Stacked panes are ruled apart as columns are, where one pane's
+ // body meets the next one's tag (acme's Border).
+ {
+ const pane_top = @min(tag.rect.y, rail.rect.y);
+ const stacked = for (regions) |other| {
+ if ((other.kind == .body or other.kind == .tag) and other.owner != rail.owner and other.rect.y + other.rect.h == pane_top and
+ other.rect.x < tag.rect.x + tag.rect.w and tag.rect.x < other.rect.x + other.rect.w) break true;
+ } else false;
+ // Inside the tag band's slack, never over its glyphs: the top
+ // slack of a tag on top, the bottom slack of the one above when
+ // tags are at the bottom; a pixel at least.
+ const y = @as(f32, @floatFromInt(pane_top)) * layout.h;
+ const spare = g.cell_h -| g.tagline_height;
+ if (stacked and !tag_bottom) {
+ const room = taglineBandOffset(pane_top, win_h, g.cell_h, g.tagline_height);
+ try addDecor(g, gpa, x0, y, rule_x1, y + @max(1, @min(rulePx(chrome), @as(f32, @floatFromInt(room)))), chrome.border, 1, track, win_w, win_h);
+ } else if (stacked and pane_top > 0) {
+ const room = spare - taglineBandOffset(pane_top - 1, win_h, g.cell_h, g.tagline_height);
+ try addDecor(g, gpa, x0, y - @max(1, @min(rulePx(chrome), @as(f32, @floatFromInt(room)))), rule_x1, y, chrome.border, 1, track, win_w, win_h);
+ }
+ }
+
+ const y0 = @as(f32, @floatFromInt(rail.rect.y)) * layout.h;
+ const body_end = rail.rect.y + rail.rect.h;
+ const body_y1 = @as(f32, @floatFromInt(body_end)) * layout.h;
+ const y1 = if (body_end == rows and win_h - body_y1 < layout.h) @max(body_y1, win_h) else body_y1;
+ // A theme's own track fills its width, the thumb one pixel short
+ // of it so the track edges it (acme's scrollbar); else a thin rail.
+ // acme's scrollbar: the track fills the scroll column, under the
+ // grip's button; the thumb is a pixel short of its right edge, so
+ // the track edges it.
+ const column = scrollColumn(g, chrome, rail.rect.x, layout);
+ try addDecor(g, gpa, x0, y0, x0 + layout.w, y1, page, 1, track, win_w, win_h);
+ if (chrome.decor_checker) |gold|
+ try addChecker(g, gpa, column[0], y0, column[1], y1, chrome.scroll_track, gold, dp(@floatFromInt(@max(1, chrome.decor_checker_px))), track, win_w, win_h)
+ else
+ try addDecor(g, gpa, column[0], y0, column[1], y1, chrome.scroll_track, 1, track, win_w, win_h);
+ if (rail.thumb_h != 0 and rail.thumb_span > 0) {
+ // In pixels, not rows, and with the picture while it glides
+ // or lags behind the core's rows (both in rows of the body).
+ const lag: f32 = if (g.glide.follow.offset != 0 and g.glide.pane == rail.owner)
+ g.glide.lagLines()
+ else if (g.scroll_pane != null and g.scroll_pane.? == rail.owner) g.scroll_lag else 0;
+ const track_px = body_y1 - y0;
+ const size = @min(track_px, @max(layout.h, rail.thumb_span * track_px));
+ const at = rail.thumb_at + lag * rail.thumb_span / @as(f32, @floatFromInt(rail.rect.h));
+ const thumb_y0 = y0 + std.math.clamp(at * track_px, 0, track_px - size);
+ const thumb_y1 = if (thumb_y0 + size >= body_y1 - 0.5) y1 else thumb_y0 + size;
+ try addDecor(g, gpa, column[0], thumb_y0, column[1] - dp(1), thumb_y1, chrome.scroll_thumb, 1, track, win_w, win_h);
+ } else if (rail.thumb_h != 0) {
+ const thumb_y0 = @as(f32, @floatFromInt(rail.rect.y + rail.thumb_y)) * layout.h;
+ const thumb_y1 = if (rail.thumb_y + rail.thumb_h == rail.rect.h) y1 else @as(f32, @floatFromInt(rail.rect.y + rail.thumb_y + rail.thumb_h)) * layout.h;
+ try addDecor(g, gpa, column[0], thumb_y0, column[1] - dp(1), thumb_y1, chrome.scroll_thumb, 1, track, win_w, win_h);
+ }
+ // A query's places' ticks over the track and thumb, where its matches
+ // are in the file (Places.addTicks); the current one last, on top.
+ const track_px = body_y1 - y0;
+ for (0..2) |pass| for (ticks) |tick| {
+ if (tick.owner != rail.owner or tick.current != (pass == 1)) continue;
+ const at = @as(f32, @floatFromInt(tick.at)) / @as(f32, @floatFromInt(pardes.panes.Places.tick_scale));
+ const h = if (tick.current) dp(3) else dp(2);
+ const ty = y0 + std.math.clamp(at * track_px, 0, track_px - h);
+ try addDecor(g, gpa, column[0], ty, column[1], ty + h, if (tick.current) chrome.match_current else chrome.match_tick, 1, track, win_w, win_h);
+ };
+ }
+}
+
+/// Halfway between two colours.
+const mixRgb = pardes.colors.mix;
+
+/// A rule's width: the theme's own, or one pixel.
+fn rulePx(chrome: *const pardes.Chrome) f32 {
+ return dp(@floatFromInt(@max(1, chrome.rule_px)));
+}
+
+/// The display's density (SDL's window display scale: 2 on a 2x screen),
+/// by which every size given in logical pixels is drawn, as acme scales its
+/// Border, ButtonBorder and Scrollgap (scalesize). Cells, glyphs and what is
+/// measured in them are already the display's pixels and are not scaled.
+/// ponytail: one window per process, so one global; per window if ever two.
+var display_scale: f32 = 1;
+
+/// The window's display scale, or PARDES_TEST_SCALE (a harness forcing 2x);
+/// a test window is 1x unless forced, whatever display it lands on, so its
+/// captures are the same on any machine.
+fn updateDisplayScale(window: *c.SDL_Window) void {
+ if (std.c.getenv("PARDES_TEST_SCALE")) |forced| {
+ display_scale = std.fmt.parseFloat(f32, std.mem.span(forced)) catch 1;
+ } else if (std.c.getenv("PARDES_TEST") != null) {
+ display_scale = 1;
+ } else {
+ const scale = c.SDL_GetWindowDisplayScale(window);
+ display_scale = if (scale > 0 and std.math.isFinite(scale)) scale else 1;
+ }
+ display_scale = std.math.clamp(display_scale, 1, 4);
+}
+
+/// A theme's ornament as the cell shader draws it (Chrome.decor_*), for the
+/// frame being built: renderFrame sets it, writing a cell marks the cells
+/// it falls on, and pushLayerOpacity hands the shader its colours and
+/// sizes. ponytail: one window per process, as display_scale.
+var cell_decor: CellDecor = .{};
+/// The cells this frame lets a plaque show through, by instance, for
+/// renderFrame to drop the ones with no ink. Past its length the frame's
+/// cells are blended instead.
+var plaque_through: [16384]u32 = undefined;
+var plaque_through_len: usize = 0;
+
+fn plaqueThrough(instances: [*]CellInstance, at: u32) void {
+ instances[at].effect |= clear_bg_bit;
+ if (plaque_through_len < plaque_through.len) plaque_through[plaque_through_len] = at;
+ plaque_through_len += 1;
+}
+const CellDecor = struct {
+ /// The page's ground, when the theme dots it.
+ dots: ?[3]u8 = null,
+ /// A file name's inks in a tag, when the theme shadows it.
+ title: ?[2][3]u8 = null,
+ /// UiUniforms after background_opacity (ui.frag.glsl): the dots' colour
+ /// and strength, their period and radii, the shadow's colour and offset.
+ uniforms: [12]f32 = @splat(0),
+ /// The tag plaques' bands (window pixels) and the tag grounds: a blank
+ /// tag cell there lets its plaque show through (tagPlaques).
+ plaques: [pardes.MAX_TAG_LAYERS][4]f32 = undefined,
+ nplaques: usize = 0,
+ grounds: [2][3]u8 = .{ .{ 0, 0, 0 }, .{ 0, 0, 0 } },
+ plaques_off: bool = false,
+ /// A see-through cell over the plaques has ink of its own, so this
+ /// frame's cells are blended (renderFrame).
+ inked_clear: bool = false,
+
+ /// G13: each body's rectangle and how far its dots have moved.
+ bodies: [pardes.MAX_PANES][4]f32 = undefined,
+ shifts: [pardes.MAX_PANES]f32 = undefined,
+ nbodies: usize = 0,
+
+ fn parallaxAt(decor: *const CellDecor, x: f32, y: f32) f32 {
+ for (decor.bodies[0..decor.nbodies], decor.shifts[0..decor.nbodies]) |band, shift|
+ if (x >= band[0] and x < band[2] and y >= band[1] and y < band[3]) return shift;
+ return 0;
+ }
+
+ fn inPlaque(decor: *const CellDecor, x: f32, y: f32) bool {
+ for (decor.plaques[0..decor.nplaques]) |band|
+ if (x >= band[0] and x < band[2] and y >= band[1] and y < band[3]) return true;
+ return false;
+ }
+
+ fn of(chrome: *const pardes.Chrome) CellDecor {
+ var out: CellDecor = .{};
+ if (chrome.decor_dots) |rgb| if (chrome.page) |page| {
+ out.dots = page;
+ out.uniforms[0..4].* = .{ unit(rgb[0]), unit(rgb[1]), unit(rgb[2]), unit(chrome.decor_dot_alpha) };
+ out.uniforms[4..8].* = .{ dp(@floatFromInt(@max(2, chrome.decor_dot_px))), 0.75 * display_scale, 1.25 * display_scale, 0 };
+ };
+ if (chrome.decor_title) |rgb| {
+ out.title = .{ chrome.name_ink, chrome.active_name_ink };
+ out.uniforms[8..12].* = .{ unit(rgb[0]), unit(rgb[1]), unit(rgb[2]), dp(@floatFromInt(@max(1, chrome.decor_title_px))) };
+ }
+ return out;
+ }
+
+ fn unit(v: u8) f32 {
+ return @as(f32, @floatFromInt(v)) / 255;
+ }
+};
+
+/// A logical pixel size in the display's pixels: rounded, at least one.
+fn dp(logical: f32) f32 {
+ return @max(1, @round(logical * display_scale));
+}
+
+/// G9's state: the selection's blocks last drawn and when each appeared.
+const SelGlow = struct {
+ const Block = struct { box: [4]u16, start_ns: u64 };
+ blocks: [32]Block = undefined,
+ len: usize = 0,
+ now_ns: u64 = 0,
+ /// A block is still fading in: the core keeps frames coming.
+ fading: bool = false,
+};
+
+/// How long a glow takes to come up (§8.1's micro-feedback: 80 to 120 ms).
+const sel_glow_ns: u64 = 100 * std.time.ns_per_ms;
+
+/// A glow's kind: G9's halo round the selection, G11's under a hovered word.
+const GlowKind = enum { selection, hover };
+
+/// G9: a soft halo of the selection's own colour round each block of it in
+/// a pane body (rows of selected cells that touch), fading in over 100 ms
+/// with an ease-out. The selection itself is the halo's caster, never
+/// touched; so is a cursor beside it; the halo stays on bodies (never a
+/// tag or a grip) and at most 22%, less where the text round it would drop
+/// below min(its contrast, 4.5).
+/// G11: under the word a look-hover would open (its cells in the
+/// affordance's tint), a soft line of the theme's accent along its foot,
+/// fading in over 80 ms, as strong at most, never under a cursor.
+fn glowBlocks(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, kind: GlowKind, layout: CellLayout, win_w: f32, win_h: f32) !void {
+ const chrome = &surface.chrome;
+ const page = chrome.page orelse bg_default;
+ const fg = chrome.fg orelse fg_default;
+ // The selection's halo is its own colour; a hovered word's underline is
+ // the theme's accent (its focused grip), like a link's.
+ const glow = if (kind == .selection) chrome.sel_bg else chrome.accent;
+ // The cells a block is made of: the selection's, or the hover
+ // affordance's tint (draw.zig: halfway to a quarter of the selection).
+ const sel = if (kind == .selection) chrome.sel_bg else mixRgb(page, mixRgb(page, chrome.sel_bg));
+ const tracker = if (kind == .selection) &g.sel_glow else &g.hover_glow;
+ const rise_ns: u64 = if (kind == .selection) sel_glow_ns else 80 * std.time.ns_per_ms;
+ const cap = @min(0.22, lightenCeiling(fg, page, glow));
+ var blocks: [32][4]u16 = undefined;
+ var nblocks: usize = 0;
+ var bodies: [pardes.MAX_PANES][4]f32 = undefined;
+ var nbodies: usize = 0;
+ for (surface.regionList()) |body| {
+ if (body.kind != .body or body.rect.w == 0) continue;
+ if (nbodies < bodies.len) {
+ bodies[nbodies] = bodyPixels(body, layout);
+ nbodies += 1;
+ }
+ var open: ?[4]u16 = null; // x0, y0, x1, y1 of the block being grown
+ var row = body.rect.y;
+ while (row < body.rect.y + body.rect.h and row < surface.rows) : (row += 1) {
+ var x0: ?u16 = null;
+ var x1: u16 = 0;
+ var col = body.rect.x;
+ while (col < body.rect.x + body.rect.w and col < surface.cols) : (col += 1) {
+ const cell = &surface.cells[@as(usize, row) * surface.cols + col];
+ const selected = !cell.default and switch (cell.style.bg) {
+ .rgb => |rgb| std.mem.eql(u8, &rgb, &sel),
+ else => false,
+ };
+ if (!selected) continue;
+ if (x0 == null) x0 = col;
+ x1 = col + 1;
+ }
+ if (x0) |start| {
+ if (open) |*block| {
+ block.* = .{ @min(block[0], start), block[1], @max(block[2], x1), row + 1 };
+ } else open = .{ start, row, x1, row + 1 };
+ } else if (open) |block| {
+ if (nblocks < blocks.len) blocks[nblocks] = block;
+ nblocks += 1;
+ open = null;
+ }
+ }
+ if (open) |block| if (nblocks < blocks.len) {
+ blocks[nblocks] = block;
+ nblocks += 1;
+ };
+ }
+ nblocks = @min(nblocks, blocks.len);
+ // Each block keeps the start of the one it overlaps from the last frame.
+ var next: SelGlow = .{ .now_ns = tracker.now_ns };
+ for (blocks[0..nblocks]) |block| {
+ const start = for (tracker.blocks[0..tracker.len]) |old| {
+ if (old.box[0] < block[2] and block[0] < old.box[2] and old.box[1] < block[3] and block[1] < old.box[3]) break old.start_ns;
+ } else tracker.now_ns;
+ next.blocks[next.len] = .{ .box = block, .start_ns = start };
+ next.len += 1;
+ const t = @as(f32, @floatFromInt(tracker.now_ns -| start)) / @as(f32, @floatFromInt(rise_ns));
+ if (t < 1) next.fading = true;
+ const u = std.math.clamp(t, 0, 1);
+ const fade = 1 - (1 - u) * (1 - u) * (1 - u);
+ var caster: [4]f32 = .{ @as(f32, @floatFromInt(block[0])) * layout.w, @as(f32, @floatFromInt(block[1])) * layout.h, @as(f32, @floatFromInt(block[2])) * layout.w, @as(f32, @floatFromInt(block[3])) * layout.h };
+ const cursor_box: ?[4]f32 = if (surface.cursor) |cu| .{ @as(f32, @floatFromInt(cu.x)) * layout.w, @as(f32, @floatFromInt(cu.y)) * layout.h, @as(f32, @floatFromInt(cu.x + 1)) * layout.w, @as(f32, @floatFromInt(cu.y + 1)) * layout.h } else null;
+ const first = g.decor.items.len;
+ switch (kind) {
+ .selection => {
+ // A cursor beside the selection is not glowed over: it
+ // joins the caster.
+ if (surface.cursor) |cu| if (cu.x + 1 >= block[0] and cu.x <= block[2] and cu.y + 1 >= block[1] and cu.y <= block[3]) {
+ const cb = cursor_box.?;
+ caster = .{ @min(caster[0], cb[0]), @min(caster[1], cb[1]), @max(caster[2], cb[2]), @max(caster[3], cb[3]) };
+ };
+ try addSoft(g, gpa, caster, 0.3 * layout.h, 0, 0, cap * fade, glow, null, win_w, win_h);
+ try clipToBodies(g, gpa, first, bodies[0..nbodies]);
+ },
+ .hover => {
+ // A strip three logical pixels tall along the word's foot,
+ // its edges blurred by one: an underline of light. It is
+ // cast from a row away (addSoft leaves its caster's own
+ // rectangle out), so all of it shows.
+ const foot = caster[3] - dp(1);
+ const away = layout.h;
+ try addSoft(g, gpa, .{ caster[0] + dp(1), foot - dp(3) - away, caster[2] - dp(1), foot - away }, dp(1), 0, away, cap * fade, glow, null, win_w, win_h);
+ // Kept to the bodies, and off a cursor: the parts either
+ // side of it.
+ var parts: [4 * pardes.MAX_PANES][4]f32 = undefined;
+ var nparts: usize = 0;
+ for (bodies[0..nbodies]) |b| {
+ const cb = cursor_box orelse {
+ parts[nparts] = b;
+ nparts += 1;
+ continue;
+ };
+ if (cb[0] >= b[2] or cb[2] <= b[0] or cb[1] >= b[3] or cb[3] <= b[1]) {
+ parts[nparts] = b;
+ nparts += 1;
+ continue;
+ }
+ // Left and right of it, and above and below it.
+ parts[nparts] = .{ b[0], b[1], cb[0], b[3] };
+ parts[nparts + 1] = .{ cb[2], b[1], b[2], b[3] };
+ parts[nparts + 2] = .{ cb[0], b[1], cb[2], cb[1] };
+ parts[nparts + 3] = .{ cb[0], cb[3], cb[2], b[3] };
+ nparts += 4;
+ }
+ try clipToBodies(g, gpa, first, parts[0..nparts]);
+ },
+ }
+ }
+ tracker.* = next;
+}
+
+/// G12: ambient occlusion, a pane body darkening faintly toward its edges
+/// (§9.1: an inner shadow of 1 to 2%): four soft strips cast from just
+/// outside the body inward, clipped to it and round a cursor, black in
+/// linear light, under the same contrast ceiling as a lift.
+fn occlusion(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, groups: *const Groups, index: usize, surface: *const pardes.Surface, ceilings: LiftCeilings, layout: CellLayout, win_w: f32, win_h: f32, track: ?pardes.animation.Track) !void {
+ const strength = @min(0.02, ceilings.shadow);
+ if (strength <= 0.002) return;
+ const reach = 0.5 * layout.h;
+ for (regions) |body| {
+ if (body.kind != .body or body.rect.w == 0 or body.rect.h == 0 or groupOf(groups, body.serial) != index) continue;
+ const b = bodyPixels(body, layout);
+ // The body, less a cursor's cell in it: left, right, above, below.
+ var parts: [4][4]f32 = undefined;
+ var nparts: usize = 0;
+ const cursor: ?[4]f32 = if (surface.cursor) |cu| .{ @as(f32, @floatFromInt(cu.x)) * layout.w, @as(f32, @floatFromInt(cu.y)) * layout.h, @as(f32, @floatFromInt(cu.x + 1)) * layout.w, @as(f32, @floatFromInt(cu.y + 1)) * layout.h } else null;
+ if (cursor) |cb| if (!(cb[0] >= b[2] or cb[2] <= b[0] or cb[1] >= b[3] or cb[3] <= b[1])) {
+ parts = .{ .{ b[0], b[1], cb[0], b[3] }, .{ cb[2], b[1], b[2], b[3] }, .{ cb[0], b[1], cb[2], cb[1] }, .{ cb[0], cb[3], cb[2], b[3] } };
+ nparts = 4;
+ };
+ if (nparts == 0) {
+ parts[0] = b;
+ nparts = 1;
+ }
+ const t = reach / 3;
+ const strips = [_][4]f32{
+ .{ b[0], b[1] - t, b[2], b[1] },
+ .{ b[0], b[3], b[2], b[3] + t },
+ .{ b[0] - t, b[1], b[0], b[3] },
+ .{ b[2], b[1], b[2] + t, b[3] },
+ };
+ for (strips) |strip| {
+ const first = g.decor.items.len;
+ try addSoft(g, gpa, strip, reach / 3, 0, 0, strength, .{ 0, 0, 0 }, track, win_w, win_h);
+ try clipToBodies(g, gpa, first, parts[0..nparts]);
+ }
+ }
+}
+
+/// A theme's tag plaques (Chrome.decor_box_*), drawn under the cells of
+/// group `index`: each pane tag, and with the still panes the column and
+/// workspace tags, becomes a framed box inside its own band with a hard
+/// shadow down and right that stays inside the band too, so it never falls
+/// on a body, a grip or the next pane. The focused pane's box is striped,
+/// its words on plates of the tag's ground (their cells stay opaque; the
+/// spaces between let the stripes through, emitInstance); a column or the
+/// workspace takes a quieter box, a one-pixel frame and a two-pixel shadow.
+fn tagPlaques(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, groups: *const Groups, index: usize, chrome: *const pardes.Chrome, layout: CellLayout, win_w: f32, win_h: f32, track: ?pardes.animation.Track) !void {
+ const border_rgb = chrome.decor_box_border orelse return;
+ if (cell_decor.plaques_off) return;
+ const page = chrome.page orelse bg_default;
+ // The workspace and column plaques first: a pane's plaque right under
+ // them shares their bottom edge (plaqueBox) and draws its frame last.
+ for ([_]bool{ false, true }) |panes| for (regions) |tag| {
+ const pane = tag.kind == .tag;
+ if (pane != panes) continue;
+ if (!pane and tag.kind != .column_tag and tag.kind != .workspace_tag) continue;
+ if (tag.rect.w == 0 or tag.rect.h == 0) continue;
+ if (pane and groupOf(groups, tag.serial) != index) continue;
+ if (!pane and index != 0) continue;
+ const plaque = plaqueBox(g, chrome, regions, tag, layout, win_w, win_h) orelse continue;
+ const b = plaque.border;
+ const sh = plaque.shadow;
+ const fill = if (tag.active) chrome.tag_focus_bg else chrome.tag_bg;
+ // The band's own ground, then the shadow, the frame and the fill,
+ // each only where the ones over it leave it showing: all four are
+ // opaque, so that is the same picture drawn once, not four times.
+ const shadow: [4]f32 = .{ plaque.box[0] + sh[0], plaque.box[1] + sh[1], plaque.box[2] + sh[0], plaque.box[3] + sh[1] };
+ const inner: [4]f32 = .{ plaque.box[0] + b, plaque.box[1] + b, plaque.box[2] - b, plaque.box[3] - b };
+ try addDecorExcept(g, gpa, plaque.band, &.{ plaque.box, shadow }, page, track, win_w, win_h);
+ const shadow_rgb = chrome.decor_box_shadow orelse border_rgb;
+ try addDecorExcept(g, gpa, shadow, &.{plaque.box}, if (pane) shadow_rgb else mixRgb(shadow_rgb, page), track, win_w, win_h);
+ try addDecorExcept(g, gpa, plaque.box, &.{inner}, border_rgb, track, win_w, win_h);
+ if (pane and tag.active and chrome.decor_box_stripe != null)
+ try addPattern(g, gpa, inner[0], inner[1], inner[2], inner[3], chrome.decor_box_stripe.?, fill, dp(@floatFromInt(@max(1, chrome.decor_box_stripe_px))), true, track, win_w, win_h)
+ else
+ try addDecor(g, gpa, inner[0], inner[1], inner[2], inner[3], fill, 1, track, win_w, win_h);
+ };
+}
+
+/// Flat decor over `rect` (window pixels) less each of `holes`: up to four
+/// strips round the first hole's part of it, each less the rest.
+fn addDecorExcept(g: *Gui, gpa: std.mem.Allocator, rect: [4]f32, holes: []const [4]f32, rgb: [3]u8, track: ?pardes.animation.Track, win_w: f32, win_h: f32) std.mem.Allocator.Error!void {
+ if (rect[0] >= rect[2] or rect[1] >= rect[3]) return;
+ if (holes.len == 0) return addDecor(g, gpa, rect[0], rect[1], rect[2], rect[3], rgb, 1, track, win_w, win_h);
+ const hole = holes[0];
+ const x0 = @max(rect[0], hole[0]);
+ const y0 = @max(rect[1], hole[1]);
+ const x1 = @min(rect[2], hole[2]);
+ const y1 = @min(rect[3], hole[3]);
+ if (x0 >= x1 or y0 >= y1) return addDecorExcept(g, gpa, rect, holes[1..], rgb, track, win_w, win_h);
+ for ([_][4]f32{
+ .{ rect[0], rect[1], rect[2], y0 },
+ .{ rect[0], y1, rect[2], rect[3] },
+ .{ rect[0], y0, x0, y1 },
+ .{ x1, y0, rect[2], y1 },
+ }) |strip| try addDecorExcept(g, gpa, strip, holes[1..], rgb, track, win_w, win_h);
+}
+
+test "decor less its holes covers each pixel of the rest once and none of the holes" {
+ const gpa = std.testing.allocator;
+ var g: Gui = undefined;
+ g.cell_w = 1;
+ g.cell_h = 1;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ const holes = [_][4]f32{ .{ 3, 2, 9, 6 }, .{ 5, 4, 12, 8 }, .{ 30, 30, 40, 40 } };
+ try addDecorExcept(&g, gpa, .{ 1, 1, 11, 10 }, &holes, .{ 1, 2, 3 }, null, 16, 12);
+ for (0..12) |y| for (0..16) |x| {
+ const px: f32 = @as(f32, @floatFromInt(x)) + 0.5;
+ const py: f32 = @as(f32, @floatFromInt(y)) + 0.5;
+ var hits: usize = 0;
+ for (g.decor.items) |item| {
+ const r: [4]f32 = .{ (item.x0 + 1) / 2 * 16, (1 - item.y0) / 2 * 12, (item.x1 + 1) / 2 * 16, (1 - item.y1) / 2 * 12 };
+ hits += @intFromBool(px > r[0] and px < r[2] and py > r[1] and py < r[3]);
+ }
+ const in_rect = px > 1 and px < 11 and py > 1 and py < 10;
+ const in_hole = for (holes) |h| {
+ if (px > h[0] and px < h[2] and py > h[1] and py < h[3]) break true;
+ } else false;
+ try std.testing.expectEqual(@as(usize, @intFromBool(in_rect and !in_hole)), hits);
+ };
+}
+
+const Plaque = struct { band: [4]f32, box: [4]f32, border: f32, shadow: [2]f32 };
+
+/// A tag's plaque in window pixels: its band (the rows, from after the
+/// grip to the end), the framed box round the tagline's text, and the
+/// frame's and the shadow's widths, the shadow cut to what the band's slack
+/// below the text and its right end leave. Null where there is no room.
+/// Tags stacked on each other (the workspace's over the columns', a
+/// column's over its first pane's) share one edge, the ruled one between
+/// their bands: the upper box runs down to it and casts no shadow down, the
+/// lower one's frame lies over it. Every box in a column spans the same
+/// pixels across, right of the grips, its shadow short of the next column.
+fn plaqueBox(g: *const Gui, chrome: *const pardes.Chrome, regions: []const pardes.Region, tag: pardes.Region, layout: CellLayout, win_w: f32, win_h: f32) ?Plaque {
+ const pane = tag.kind == .tag;
+ const first = tag.rect.y;
+ const last = tag.rect.y + tag.rect.h - 1;
+ // Flush against its grip's button, so the two read as one piece: the
+ // gap between button and text (the scroll gap) is the plaque's, and so
+ // is the cell before its text, so its frame is never under the first
+ // letter. A column's plaque starts where the pane's under it does.
+ const grip_kind: pardes.Region.Kind = if (tag.kind == .column_tag) .column_grip else .grip;
+ const x0 = for (regions) |grip| {
+ if (tag.kind != .workspace_tag and grip.kind == grip_kind and grip.owner == tag.owner)
+ break scrollColumn(g, chrome, grip.rect.x, layout)[1];
+ } else @as(f32, @floatFromInt(tag.rect.x)) * layout.w;
+ const x1_cells = @as(f32, @floatFromInt(tag.rect.x + tag.rect.w)) * layout.w;
+ const window_edge = win_w - x1_cells < layout.w;
+ const x1 = if (window_edge) @max(x1_cells, win_w) else x1_cells;
+ const stacked_on = tagBandAt(regions, tag, .above);
+ const stacked_under = tagBandAt(regions, tag, .below);
+ const row_top = @as(f32, @floatFromInt(first)) * layout.h;
+ const row_bottom = @as(f32, @floatFromInt(last + 1)) * layout.h;
+ const text_top = row_top + @as(f32, @floatFromInt(taglineBandOffset(first, win_h, g.cell_h, g.tagline_height)));
+ const text_bottom = @as(f32, @floatFromInt(last)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(last, win_h, g.cell_h, g.tagline_height) + g.tagline_height));
+ const border = @min(if (pane) dp(@floatFromInt(@max(1, chrome.decor_box_border_px))) else dp(1), @floor(text_top - row_top));
+ if (border < 1) return null;
+ // The shadow's full offset to the right; down, what the slack under the
+ // text leaves (a pixel or three at a tagline under the body's size).
+ const want: f32 = if (pane) dp(@floatFromInt(chrome.decor_box_shadow_px)) else dp(2);
+ const drop = if (stacked_under) 0 else std.math.clamp(@floor(row_bottom - text_bottom - border), 0, want);
+ // Every box ends where a pane's does, short of the next column's rule
+ // by a pane frame's width past its shadow, so no shadow meets the rule
+ // and a column's box lines up with its panes'; the window's edge needs
+ // no gap.
+ const pane_shadow = dp(@floatFromInt(chrome.decor_box_shadow_px));
+ const gap = @max(0, pane_shadow - want) + if (window_edge) 0 else dp(@floatFromInt(@max(1, chrome.decor_box_border_px)));
+ if (x1 - x0 < 4 * border + want + gap) return null;
+ return .{
+ .band = .{ x0, row_top, x1, row_bottom },
+ .box = .{
+ x0,
+ if (stacked_on) row_top - border else text_top - border,
+ x1 - want - gap,
+ if (stacked_under) row_bottom else text_bottom + border,
},
- );
+ .border = border,
+ .shadow = .{ want, drop },
+ };
}
-fn buildOverlay(
- g: *Gui,
- core: ?*const pardes.Pardes,
- surface: *const pardes.Surface,
- layout: CellLayout,
- sw: u32,
- sh: u32,
- topbar_pane_border_rgb: [3]u8,
- tagline_rgb: [3]u8,
- transient_on: bool,
- debug_on: bool,
-) u32 {
- if (g.overlay_vertices.len == 0 or sw == 0 or sh == 0) return 0;
- const win_w: f32 = @floatFromInt(sw);
- const win_h: f32 = @floatFromInt(sh);
- var builder = OverlayBuilder{ .vertices = g.overlay_vertices, .win_w = win_w, .win_h = win_h };
- appendWorkspacePet(g, core, surface, &builder);
- if (topbarPaneBorderHeight(surface, g.cell_h, g.tagline_height)) |height| {
- const y0: f32 = @floatFromInt(g.cell_h - height / 2);
- const rgb = topbar_pane_border_rgb;
- builder.addRect(0, y0, win_w, y0 + @as(f32, @floatFromInt(height)), .{
- .r = @as(f32, @floatFromInt(rgb[0])) / 255.0,
- .g = @as(f32, @floatFromInt(rgb[1])) / 255.0,
- .b = @as(f32, @floatFromInt(rgb[2])) / 255.0,
- .a = 1.0,
- });
+/// Whether another tag's band (the workspace's, a column's, a pane's) meets
+/// `tag`'s right above or below it, across some of its width.
+fn tagBandAt(regions: []const pardes.Region, tag: pardes.Region, side: enum { above, below }) bool {
+ for (regions) |other| {
+ if (other.kind != .tag and other.kind != .column_tag and other.kind != .workspace_tag) continue;
+ if (other.rect.h == 0 or std.meta.eql(other.rect, tag.rect)) continue;
+ const meets = switch (side) {
+ .above => other.rect.y + other.rect.h == tag.rect.y,
+ .below => tag.rect.y + tag.rect.h == other.rect.y,
+ };
+ if (meets and other.rect.x < tag.rect.x + tag.rect.w and tag.rect.x < other.rect.x + other.rect.w) return true;
+ }
+ return false;
+}
+
+/// The two short bars on each row of a grip with no mode glyph there,
+/// centered in its anchor. Only the panes of group `index`.
+fn gripDecor(g: *Gui, gpa: std.mem.Allocator, regions: []const pardes.Region, cells: []const pardes.Cell, groups: *const Groups, index: usize, chrome: *const pardes.Chrome, layout: CellLayout, cols: u16, rows: u16, win_w: f32, win_h: f32, track: ?pardes.animation.Track) !void {
+ if (g.tagline_height < 6 or g.tagline_width < 3) return;
+ for (regions) |grip| {
+ if ((grip.kind != .grip and grip.kind != .column_grip) or groupOf(groups, grip.serial) != index) continue;
+ if (grip.rect.h == 0 or grip.rect.y >= rows) continue;
+ const button = gripButton(g, chrome, grip.rect.x, grip.rect.y, layout, win_h);
+ // Round the button, its first row is the tag's band: nothing of the
+ // cells under it shows there.
+ const band = if (grip.active) chrome.tag_focus_bg else chrome.tag_bg;
+ const left = @as(f32, @floatFromInt(grip.rect.x)) * layout.w;
+ const right = @as(f32, @floatFromInt(grip.rect.x + grip.rect.w)) * layout.w;
+ try addDecor(g, gpa, left, button[1], button[0], button[3], band, 1, track, win_w, win_h);
+ // Right of it, a theme's plaque starts flush against it (plaqueBox).
+ const plaqued = chrome.decor_box_border != null and !cell_decor.plaques_off;
+ if (!plaqued) try addDecor(g, gpa, button[2], button[1], right, button[3], band, 1, track, win_w, win_h);
+ // Its cells over the plaque's reach are let through (emitInstance):
+ // under the button's row, the band goes on as far as the plaque.
+ if (plaqued and grip.rect.h > 1)
+ try addDecor(g, gpa, left, button[3], button[2], @as(f32, @floatFromInt(grip.rect.y + grip.rect.h)) * layout.h, band, 1, track, win_w, win_h);
+ if (grip.kind != .grip) continue;
+ // acme's button ring, two pixels (ButtonBorder) inside the button:
+ // the focused one's in its own fill. An unfocused dirty one keeps a
+ // pixel of band inside its ring, so the four states differ in shape
+ // whatever a theme's colours (a focused dirty one is acme's
+ // modbutton, filled up to its ring).
+ {
+ // The rules drawn over the row (paneDecor, after this) cut into
+ // it: the ring runs inside them, from rule to rule.
+ const tag = for (regions) |part| {
+ if (part.kind == .tag and part.owner == grip.owner) break part;
+ } else grip;
+ const tag_bottom = for (regions) |part| {
+ if (part.kind == .rail and part.owner == grip.owner) break part.rect.y < tag.rect.y;
+ } else false;
+ const stacked = !tag_bottom and for (regions) |other| {
+ if ((other.kind == .body or other.kind == .tag) and other.owner != grip.owner and other.rect.y + other.rect.h == grip.rect.y and
+ other.rect.x < tag.rect.x + tag.rect.w and tag.rect.x < other.rect.x + other.rect.w) break true;
+ } else false;
+ const top_rule: f32 = if (tag_bottom) dp(1) else if (stacked) @max(1, @min(rulePx(chrome), @as(f32, @floatFromInt(taglineBandOffset(grip.rect.y, win_h, g.cell_h, g.tagline_height))))) else 0;
+ const bottom_rule: f32 = if (!tag_bottom and grip.rect.h == 1) dp(1) else 0;
+ const x0 = button[0];
+ const x1 = button[2];
+ const y0 = button[1] + top_rule;
+ const y1 = button[3] - bottom_rule;
+ const ring = if (grip.active) chrome.grip_focus_ring else chrome.grip_border;
+ // acme's ButtonBorder: two logical pixels.
+ const b = dp(2);
+ try addDecor(g, gpa, x0, y0, x1, y0 + b, ring, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x0, y1 - b, x1, y1, ring, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x0, y0 + b, x0 + b, y1 - b, ring, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x1 - b, y0 + b, x1, y1 - b, ring, 1, track, win_w, win_h);
+ if (grip.dirty and !grip.active) {
+ const gap = b + dp(1);
+ try addDecor(g, gpa, x0 + b, y0 + b, x1 - b, y0 + gap, band, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x0 + b, y1 - gap, x1 - b, y1 - b, band, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x0 + b, y0 + gap, x0 + gap, y1 - gap, band, 1, track, win_w, win_h);
+ try addDecor(g, gpa, x1 - gap, y0 + gap, x1 - b, y1 - gap, band, 1, track, win_w, win_h);
+ }
+ }
+ const x = grip.rect.x;
+ for (0..grip.rect.h) |line| {
+ const y = grip.rect.y + @as(u16, @intCast(line));
+ if (x >= cols or y >= rows) continue;
+ const cell = &cells[@as(usize, y) * cols + x];
+ if (cell.default or cell.printableAscii() != ' ') continue;
+ // The marks are in the button's ink, from the region's state.
+ const rgb = inkOn(gripFill(chrome, grip.active, grip.dirty));
+ // The marks are the first row's alone, centered in the button.
+ if (line != 0) continue;
+ const center_x = @floor((button[0] + button[2]) / 2);
+ const center_y = @as(f32, @floatFromInt(y)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(y, win_h, g.cell_h, g.tagline_height))) + @as(f32, @floatFromInt(g.tagline_height)) / 2;
+ const half_w = @max(dp(1), @min(dp(3), @floor((button[2] - button[0] - 2 * dp(3)) / 2)));
+ // The mode's two bars: a logical pixel thick, a pixel either
+ // side of the middle.
+ const bar = dp(1);
+ try addDecor(g, gpa, @floor(center_x - half_w), @floor(center_y - bar - dp(1)), @floor(center_x + half_w), @floor(center_y - dp(1)), rgb, 1, track, win_w, win_h);
+ try addDecor(g, gpa, @floor(center_x - half_w), @floor(center_y + dp(1)), @floor(center_x + half_w), @floor(center_y + dp(1) + bar), rgb, 1, track, win_w, win_h);
+ }
}
- if (core) |p| if (p.columnBarHeight() > 0) {
- const y = @as(f32, @floatFromInt(pardes.TOPBAR_H + p.columnBarHeight())) * layout.h;
- builder.addRect(0, y - 1, win_w, y, overlayRgb(p.chromeTheme().border));
+}
+
+test "a theme's own rules and scrollbar are drawn at its widths: acme's 2px black rules and 12px track" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme acme"));
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expectEqual(@as(u8, 2), s.chrome.rule_px);
+ // acme's 12px, at GripWidth's 150% default.
+ try std.testing.expectEqual(@as(u8, 18), s.chrome.rail_px);
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 16;
+ g.cell_h = 20;
+ g.tagline_width = 10;
+ g.tagline_height = 12;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 1280, 480, true);
+ const px = struct {
+ fn w(item: CellInstance) f32 {
+ return (item.x1 - item.x0) / 2 * 1280;
+ }
};
- const grid_bottom = @as(f32, @floatFromInt(surface.rows)) * layout.h;
- if (grid_bottom < win_h and bottomTaglinePresent(surface)) {
- const rgb = tagline_rgb;
- builder.addRect(0, grid_bottom, win_w, win_h, .{
- .r = @as(f32, @floatFromInt(rgb[0])) / 255.0,
- .g = @as(f32, @floatFromInt(rgb[1])) / 255.0,
- .b = @as(f32, @floatFromInt(rgb[2])) / 255.0,
- .a = 1.0,
- });
+ var spines: usize = 0;
+ var tracks: usize = 0;
+ for (g.decor.items) |item| {
+ const black = item.br == 0 and item.bg == 0 and item.bb == 0;
+ // No rule at the window's left edge; one 2px spine where columns meet.
+ if (black and @abs(px.w(item) - 2) < 0.01 and item.y1 < -0.9) {
+ try std.testing.expect(item.x0 > -1);
+ spines += 1;
+ }
+ const column = scrollColumn(&g, &s.chrome, 40, fixedCellLayout(&g));
+ if (@abs(item.br - @as(f32, 0x99) / 255) < 1e-3 and @abs(item.bb - @as(f32, 0x4c) / 255) < 1e-3 and @abs(px.w(item) - (column[1] - column[0])) < 0.01) tracks += 1;
}
- if (transient_on) {
- if (core) |p| appendPaneChrome(p, surface, layout, &builder);
- appendTagGrips(g, surface, layout, &builder);
- if (surface.cursor) |cursor| {
- if (cursor.x < surface.cols and cursor.y < surface.rows and bodyLayerAt(surface, cursor.x, cursor.y) == null and tagLayerIn(surface.tagLayers(), cursor.x, cursor.y) == null) {
- const cell = surface.cells[@as(usize, cursor.y) * surface.cols + cursor.x];
- const role = cellFontRole(&cell);
- const visual_height: f32 = if (role == .tagline)
- @floatFromInt(g.tagline_height)
- else
- layout.h;
- const cursor_layout = if (role == .tagline)
- taglineLayoutForCell(g, cursor.x)
- else
- layout;
- addCursorBar(&builder, cursor.x, cursor.y, cursor.bar, visual_height, cursor_layout, cursorColor(core, &cell, role));
+ try std.testing.expectEqual(@as(usize, 1), spines);
+ try std.testing.expect(tracks >= 2);
+}
+
+test "the scrollbar thumb moves by the pixel and follows a glide" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ const pane = try core.setTestFile(std.mem.asBytes(&@as([1000][5]u8, @splat("line\n".*))));
+ var g: Gui = undefined;
+ g.decor = .empty;
+ defer g.decor.deinit(gpa);
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ const thumb = struct {
+ // The thumb's top, in window pixels.
+ fn top(gui: *Gui, p: *pardes.Pardes) !f32 {
+ gui.decor.clearRetainingCapacity();
+ p.sync();
+ const s = try p.render(p.scratch.allocator());
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(gui, std.testing.allocator, s, &groups, fixedCellLayout(gui), 800, 480, true);
+ const ink = s.chrome.scroll_thumb;
+ for (gui.decor.items) |item| if (@abs(item.br - @as(f32, @floatFromInt(ink[0])) / 255) < 1e-3 and
+ @abs(item.bg - @as(f32, @floatFromInt(ink[1])) / 255) < 1e-3 and
+ @abs(item.bb - @as(f32, @floatFromInt(ink[2])) / 255) < 1e-3) return (1 - item.y0) / 2 * 480;
+ return error.TestExpectedThumb;
+ }
+ };
+ pane.file.?.scroll = 10;
+ const at10 = try thumb.top(&g, core);
+ pane.file.?.scroll = 11;
+ const at11 = try thumb.top(&g, core);
+ // A line of a thousand moves it a fraction of a row, not 0 or 20 px.
+ try std.testing.expect(at11 > at10 and at11 - at10 < 1);
+ g.glide.pane = core.active;
+ g.glide.follow.offset = -1;
+ try std.testing.expectApproxEqAbs(at10, try thumb.top(&g, core), 1e-3);
+ // A wrapped line: the picture moved two rows for the one line, and the
+ // thumb lags the line, not two.
+ g.glide.lines_moved = 1;
+ g.glide.rows_moved = 2;
+ g.glide.follow.offset = -2;
+ try std.testing.expectApproxEqAbs(at10, try thumb.top(&g, core), 1e-3);
+}
+
+test "the rule between stacked panes stays in the tag band's slack, at any tagline size" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ core.newScratchBelow(0);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ const lower = for (s.regionList()) |region| {
+ if (region.kind == .tag and region.rect.y > 2) break region;
+ } else return error.TestExpectedStackedTag;
+ for ([_]u32{ 12, 20 }) |tagline_h| {
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = tagline_h;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+ const top = @as(f32, @floatFromInt(lower.rect.y)) * 20;
+ const slack: f32 = @floatFromInt(@max(1, pardes.taglineBandOffset(lower.rect.y, 480, 20, tagline_h)));
+ var found = false;
+ for (g.decor.items) |item| {
+ const y0 = (1 - item.y0) / 2 * 480;
+ const y1 = (1 - item.y1) / 2 * 480;
+ if (@abs(y0 - top) > 0.01 or @abs(item.br - @as(f32, @floatFromInt(s.chrome.border[0])) / 255) > 1e-3) continue;
+ found = true;
+ try std.testing.expect(y1 - y0 <= slack + 0.01);
+ }
+ try std.testing.expect(found);
+ }
+}
+
+test "an empty column is ruled on both sides, as between two filled ones" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ // Newcol from the left pane: an empty column between the two filled ones.
+ core.newColumn(0);
+ core.sync();
+ try std.testing.expectEqual(@as(usize, 3), core.ncol);
+ try std.testing.expectEqual(@as(usize, 0), core.col_n[1]);
+ const s = try core.render(core.scratch.allocator());
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ const layout = fixedCellLayout(&g);
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, layout, 800, 480, true);
+ const border = [3]f32{ @as(f32, @floatFromInt(s.chrome.border[0])) / 255, @as(f32, @floatFromInt(s.chrome.border[1])) / 255, @as(f32, @floatFromInt(s.chrome.border[2])) / 255 };
+ // Its left edge and its right edge (the next column's left): each a
+ // rule `rule_px` wide in the border colour, down to the window's foot.
+ for ([_]usize{ 1, 2 }) |column| {
+ const px: f32 = @floatFromInt(@as(u32, core.col_x[column]) * 10);
+ const rule = for (g.decor.items) |item| {
+ if (@abs(item.x0 - (px / 800 * 2 - 1)) < 1e-4 and @abs(item.x1 - ((px + @as(f32, @floatFromInt(s.chrome.rule_px))) / 800 * 2 - 1)) < 1e-4 and
+ std.mem.eql(f32, &.{ item.br, item.bg, item.bb }, &border)) break item;
+ } else return error.TestExpectedColumnRule;
+ try std.testing.expectEqual(@as(f32, -1), rule.y1);
+ }
+}
+
+test "at a 2x display every logical pixel is two: rules, the tag rule, the grip's ring, the rail's edge" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme acme"));
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ for ([_]f32{ 1, 2 }) |scale| {
+ display_scale = scale;
+ defer display_scale = 1;
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 16;
+ g.cell_h = 32;
+ g.tagline_width = 12;
+ g.tagline_height = 24;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 1280, 768, true);
+ const w = struct {
+ fn of(item: CellInstance) f32 {
+ return (item.x1 - item.x0) / 2 * 1280;
}
+ fn h(item: CellInstance) f32 {
+ return (item.y0 - item.y1) / 2 * 768;
+ }
+ };
+ var spine: ?f32 = null;
+ var tag_rule: ?f32 = null;
+ var ring: ?f32 = null;
+ for (g.decor.items) |item| {
+ const rgb: [3]u8 = .{ @intFromFloat(@round(item.br * 255)), @intFromFloat(@round(item.bg * 255)), @intFromFloat(@round(item.bb * 255)) };
+ // The spine between the columns: black, tall.
+ if (std.mem.eql(u8, &rgb, &.{ 0, 0, 0 }) and w.h(item) > 300) spine = @round(w.of(item));
+ // The tag rule: #8888cc, wide and thin.
+ if (std.mem.eql(u8, &rgb, &.{ 0x88, 0x88, 0xcc }) and w.of(item) > 200) tag_rule = @round(w.h(item));
+ // The ring's left side: #8888cc, a tag row tall.
+ if (std.mem.eql(u8, &rgb, &.{ 0x88, 0x88, 0xcc }) and w.h(item) > 10 and w.of(item) < 8) ring = @round(w.of(item));
}
+ try std.testing.expectEqual(@as(?f32, 2 * scale), spine);
+ try std.testing.expectEqual(@as(?f32, 1 * scale), tag_rule);
+ try std.testing.expectEqual(@as(?f32, 2 * scale), ring);
+ // The rail starts after the rule, a logical 2 in, and keeps a
+ // logical 3 clear of the text when the cell is narrow.
+ const column = scrollColumn(&g, &s.chrome, 40, fixedCellLayout(&g));
+ try std.testing.expectEqual(40 * 16 + 2 * scale, column[0]);
+ g.cell_w = 12;
+ defer g.cell_w = 16;
+ const narrow = scrollColumn(&g, &s.chrome, 40, fixedCellLayout(&g));
+ try std.testing.expectEqual(@as(f32, 40 * 12 + 2 * scale), narrow[0]);
+ try std.testing.expectEqual(@as(f32, 40 * 12) + 12 * @as(f32, @floatFromInt(config.GUTTER)) - 3 * scale, narrow[1]);
+ g.cell_w = 8;
+ // A bar cursor is an eighth of its cell, never under a logical pixel
+ // (an 8 px cell: one pixel, two at 2x).
+ const saved = s.cursor;
+ defer s.cursor = saved;
+ s.cursor = .{ .x = 60, .y = 10, .bar = true };
+ var boxes: [max_cursors]CursorBox = undefined;
+ const n = cursorBoxes(&g, s, fixedCellLayout(&g), 768, &boxes);
+ const bar = for (boxes[0..n]) |box| {
+ if (box.bar and box.x0 == 60 * 8) break box;
+ } else return error.NoBarCursor;
+ try std.testing.expectEqual(scale, bar.x1 - bar.x0);
}
- if (transient_on) for (surface.bodyLayers()) |*layer| {
+}
+
+test "decor is read from the regions, each pane's in its own group" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ const layout = fixedCellLayout(&g);
+ const ndc = struct {
+ fn x(px: f32) f32 {
+ return px / 800 * 2 - 1;
+ }
+ };
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, layout, 800, 480, true);
+ // A spine one pixel wide at each column's left edge, down from under the
+ // workspace tag; a rail two pixels wide at each pane's.
+ for (core.col_x[0..core.ncol]) |x| {
+ const left = ndc.x(@as(f32, @floatFromInt(x)) * 10);
+ // Two pixels (rule_px), and none at the window's own edge.
+ const spine = for (g.decor.items) |item| {
+ if (item.x0 == left and @abs(item.x1 - ndc.x(@as(f32, @floatFromInt(x)) * 10 + 2)) < 0.0001 and
+ @abs(item.y0 - (1 - 20.0 / 480.0 * 2)) < 0.0001 and std.mem.eql(f32, &.{ item.br, item.bg, item.bb }, &.{ @as(f32, @floatFromInt(s.chrome.border[0])) / 255, @as(f32, @floatFromInt(s.chrome.border[1])) / 255, @as(f32, @floatFromInt(s.chrome.border[2])) / 255 })) break item;
+ } else null;
+ try std.testing.expectEqual(x == 0, spine == null);
+ if (spine) |rule| {
+ try std.testing.expectApproxEqAbs(@as(f32, 1 - 20.0 / 480.0 * 2), rule.y0, 0.0001);
+ try std.testing.expectEqual(@as(f32, -1), rule.y1);
+ }
+ // The scrollbar fills the scroll column right of the rule.
+ const column = scrollColumn(&g, &s.chrome, x, layout);
+ const rail = for (g.decor.items) |item| {
+ if (@abs(item.x0 - ndc.x(column[0])) < 0.0001 and @abs(item.x1 - ndc.x(column[1])) < 0.0001 and
+ @abs(item.br - @as(f32, @floatFromInt(s.chrome.scroll_track[0])) / 255) < 0.0001) break item;
+ } else return error.TestExpectedRail;
+ _ = rail;
+ }
+ try std.testing.expectEqual(@as(u32, 0), groups.items[groups.notices].decor_count);
+ const still = groups.items[0].decor_count;
+
+ // Pane 1 moving: its rule and rail leave tier 0 for its track's group,
+ // which moves them with it.
+ const serial = core.panes[1].?.serial;
+ const moving: pardes.animation.Track = .{ .pane = 1, .serial = serial, .phase = .moving, .effect = .slide, .from = .{ .x = 0, .y = 1, .w = 40, .h = 23 }, .to = .{ .x = 40, .y = 1, .w = 40, .h = 23 } };
+ groups = makeGroups(&.{moving}, true);
+ try buildDecor(&g, gpa, s, &groups, layout, 800, 480, groups.tracks == 0);
+ const tracked = groups.items[1];
+ try std.testing.expect(tracked.decor_count >= 4);
+ try std.testing.expectEqual(still, groups.items[0].decor_count + tracked.decor_count);
+ for (g.decor.items[tracked.decor_start..][0..tracked.decor_count]) |item|
+ try std.testing.expectEqual(@as(u32, @backingInt(pardes.animation.Transition.slide)), item.effect);
+ // Cursors stand still while panes move.
+ try std.testing.expectEqual(@as(u32, 0), groups.items[groups.ink].decor_count);
+}
+
+test "a pane on the move casts a shadow on the other panes' bodies alone, most at mid-way" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.newShell(1, "");
+ try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme acme"));
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ const layout = fixedCellLayout(&g);
+ const serial = core.panes[1].?.serial;
+ var strengths: [3]f32 = @splat(0);
+ for ([_]u16{ 0, 6, 12 }, 0..) |frame, i| {
+ g.decor.clearRetainingCapacity();
+ const moving: pardes.animation.Track = .{ .pane = 1, .serial = serial, .phase = .moving, .effect = .slide, .frame = frame, .frame_count = 13, .from = .{ .x = 0, .y = 1, .w = 40, .h = 23 }, .to = .{ .x = 40, .y = 1, .w = 40, .h = 23 } };
+ var groups = makeGroups(&.{moving}, true);
+ if (!moving.active()) groups = makeGroups(&.{}, true);
+ try buildDecor(&g, gpa, s, &groups, layout, 800, 480, false);
+ for (g.decor.items) |item| {
+ if (item.effect & soft_shadow_bit == 0) continue;
+ strengths[i] = @max(strengths[i], item.fr);
+ // Clipped to pane 0's body or rail, never pane 1's, never a tag.
+ try std.testing.expect(item.clip_x1 >= item.clip_x0);
+ for (s.regionList()) |region| {
+ if (region.kind != .tag and region.kind != .grip and !(region.owner == 1 and (region.kind == .body or region.kind == .rail))) continue;
+ const r = bodyPixels(region, layout);
+ try std.testing.expect(item.clip_x1 <= r[0] or item.clip_x0 >= r[2] or item.clip_y1 <= r[1] or item.clip_y0 >= r[3]);
+ }
+ }
+ }
+ // Rising as it sets out, gone as it lands.
+ try std.testing.expectEqual(@as(f32, 0), strengths[0]);
+ try std.testing.expect(strengths[1] > 0.05);
+ try std.testing.expectEqual(@as(f32, 0), strengths[2]);
+}
+
+test "the selection glows round its block, on the body only, fading in over 100 ms" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.setTestFile(std.mem.asBytes(&@as([30][20]u8, @splat("some text on a line\n".*))));
+ core.settings.selection_glow = true;
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expectEqual(@as(u8, 1), s.chrome.fx);
+ // Two rows of a selection in the body, as the core paints one.
+ const body = for (s.regionList()) |region| {
+ if (region.kind == .body) break region;
+ } else return error.NoBody;
+ for (0..2) |dy| for (5..12) |x| {
+ const cell = &s.cells[(@as(usize, body.rect.y) + 3 + dy) * s.cols + body.rect.x + x];
+ cell.default = false;
+ cell.style.bg = .{ .rgb = s.chrome.sel_bg };
+ };
+ s.cursor = null;
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ g.sel_glow = .{ .now_ns = std.time.ns_per_s };
+ var strengths: [2]f32 = .{ 0, 0 };
+ for ([_]u64{ 0, 150 * std.time.ns_per_ms }, 0..) |later, i| {
+ g.decor.clearRetainingCapacity();
+ g.sel_glow.now_ns = std.time.ns_per_s + later;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+ for (g.decor.items) |item| {
+ if (item.effect & soft_shadow_bit == 0) continue;
+ const rgb: [3]u8 = .{ @intFromFloat(@round(item.br * 255)), @intFromFloat(@round(item.bg * 255)), @intFromFloat(@round(item.bb * 255)) };
+ if (!std.mem.eql(u8, &rgb, &s.chrome.sel_bg)) continue;
+ strengths[i] = @max(strengths[i], item.fr);
+ // On the body alone.
+ const r = bodyPixels(body, fixedCellLayout(&g));
+ try std.testing.expect(item.clip_x0 >= r[0] - 0.01 and item.clip_x1 <= r[2] + 0.01 and item.clip_y0 >= r[1] - 0.01 and item.clip_y1 <= r[3] + 0.01);
+ }
+ try std.testing.expectEqual(@as(usize, 1), g.sel_glow.len);
+ }
+ // Just appeared: nothing yet, and still fading; later, up to its cap.
+ try std.testing.expectEqual(@as(f32, 0), strengths[0]);
+ try std.testing.expect(strengths[1] > 0.05 and strengths[1] <= 0.22 + 1e-4);
+ try std.testing.expect(!g.sel_glow.fading);
+}
+
+test "a hovered word glows along its foot, never over the cursor, fading in over 80 ms" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.setTestFile(std.mem.asBytes(&@as([30][20]u8, @splat("some text on a line\n".*))));
+ core.settings.hover_glow = true;
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expectEqual(@as(u8, 2), s.chrome.fx);
+ const body = for (s.regionList()) |region| {
+ if (region.kind == .body) break region;
+ } else return error.NoBody;
+ const page = s.chrome.page orelse bg_default;
+ const tint = mixRgb(page, mixRgb(page, s.chrome.sel_bg));
+ const row = body.rect.y + 4;
+ for (5..12) |x| {
+ const cell = &s.cells[@as(usize, row) * s.cols + body.rect.x + x];
+ cell.default = false;
+ cell.style.bg = .{ .rgb = tint };
+ }
+ s.cursor = .{ .x = body.rect.x + 8, .y = row };
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ g.sel_glow = .{};
+ g.hover_glow = .{ .now_ns = std.time.ns_per_s };
+ var strongest: f32 = 0;
+ for ([_]u64{ 0, 90 * std.time.ns_per_ms }) |later| {
+ g.decor.clearRetainingCapacity();
+ g.hover_glow.now_ns = std.time.ns_per_s + later;
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+ for (g.decor.items) |item| {
+ if (item.effect & soft_shadow_bit == 0) continue;
+ if (later == 0) try std.testing.expect(false);
+ strongest = @max(strongest, item.fr);
+ // Never over the cursor's cell.
+ const cx0: f32 = @floatFromInt(@as(u32, s.cursor.?.x) * 10);
+ const cy0: f32 = @floatFromInt(@as(u32, s.cursor.?.y) * 20);
+ try std.testing.expect(item.clip_x1 <= cx0 + 0.01 or item.clip_x0 >= cx0 + 10 - 0.01 or item.clip_y1 <= cy0 + 0.01 or item.clip_y0 >= cy0 + 20 - 0.01);
+ }
+ }
+ try std.testing.expect(strongest > 0.05);
+ try std.testing.expect(!g.hover_glow.fading);
+}
+
+test "occlusion shades each body's edges, inside it, never a tag, a grip or the cursor" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ _ = try core.setTestFile(std.mem.asBytes(&@as([30][20]u8, @splat("some text on a line\n".*))));
+ core.settings.occlusion = true;
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ try std.testing.expectEqual(@as(u8, 4), s.chrome.fx);
+ const body = for (s.regionList()) |region| {
+ if (region.kind == .body) break region;
+ } else return error.NoBody;
+ // The cursor on the body's top-left cell, where the shade is.
+ s.cursor = .{ .x = body.rect.x, .y = body.rect.y };
+ var g: Gui = undefined;
+ g.decor = .empty;
+ g.glide = .{};
+ g.scroll_pane = null;
+ g.scroll_lag = 0;
+ defer g.decor.deinit(gpa);
+ g.cell_w = 10;
+ g.cell_h = 20;
+ g.tagline_width = 6;
+ g.tagline_height = 12;
+ g.sel_glow = .{};
+ g.hover_glow = .{};
+ var groups = makeGroups(&.{}, false);
+ try buildDecor(&g, gpa, s, &groups, fixedCellLayout(&g), 800, 480, true);
+ const r = bodyPixels(body, fixedCellLayout(&g));
+ var shades: usize = 0;
+ for (g.decor.items) |item| {
+ if (item.effect & soft_shadow_bit == 0) continue;
+ shades += 1;
+ try std.testing.expect(item.fr <= 0.02 + 1e-6);
+ try std.testing.expect(item.clip_x0 >= r[0] - 0.01 and item.clip_x1 <= r[2] + 0.01 and item.clip_y0 >= r[1] - 0.01 and item.clip_y1 <= r[3] + 0.01);
+ const cx: f32 = @floatFromInt(@as(u32, s.cursor.?.x) * 10);
+ const cy: f32 = @floatFromInt(@as(u32, s.cursor.?.y) * 20);
+ try std.testing.expect(item.clip_x1 <= cx + 0.01 or item.clip_x0 >= cx + 10 - 0.01 or item.clip_y1 <= cy + 0.01 or item.clip_y0 >= cy + 20 - 0.01);
+ }
+ try std.testing.expect(shades >= 4);
+}
+
+test "a body tells its first line, and lapis's dots under it move a quarter as far" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 80, .rows = 24 });
+ defer core.deinit();
+ const pane = try core.setTestFile(std.mem.asBytes(&@as([80][5]u8, @splat("line\n".*))));
+ pane.scrollBy(8);
+ try std.testing.expect(core.executeBuiltinLine(0, "Theme lapis"));
+ core.settings.parallax = true;
+ for (0..40) |_| core.update(.tick);
+ core.sync();
+ const s = try core.render(core.scratch.allocator());
+ const body = for (s.regionList()) |region| {
+ if (region.kind == .body) break region;
+ } else return error.NoBody;
+ try std.testing.expectEqual(@as(i32, 8), body.line);
+ try std.testing.expect(s.chrome.fx & 8 != 0);
+ // The shift the cell shader is handed: a quarter of 8 rows of 20 px,
+ // upward, within the dots' period.
+ var decor = CellDecor.of(&s.chrome);
+ const period = decor.uniforms[4];
+ decor.bodies[0] = .{ 0, 0, 800, 480 };
+ decor.shifts[0] = @mod(-8.0 * 20.0 * 0.25, period);
+ decor.nbodies = 1;
+ try std.testing.expectApproxEqAbs(@mod(-40.0, period), decor.parallaxAt(10, 10), 1e-4);
+ try std.testing.expectEqual(@as(f32, 0), decor.parallaxAt(900, 10));
+}
+
+/// What a bundled post pass leaves alone (Post.Frame.spare), in window
+/// pixels: every tag with its grip, the column and workspace tags, and the
+/// notices, the chrome the focus indicators live in. A grip, the gap after
+/// it and the tag beside it are one rectangle; past the list's end the last
+/// grows to cover the rest.
+fn postSpare(surface: *const pardes.Surface, layout: CellLayout, out: *[Post.max_spare][4]f32) usize {
+ var n: usize = 0;
+ for (surface.regionList()) |region| {
+ switch (region.kind) {
+ .grip, .tag, .notice, .column_grip, .column_tag, .workspace_tag => {},
+ else => continue,
+ }
+ if (region.rect.w == 0 or region.rect.h == 0) continue;
+ const rect: [4]f32 = .{
+ @as(f32, @floatFromInt(region.rect.x)) * layout.w,
+ @as(f32, @floatFromInt(region.rect.y)) * layout.h,
+ @as(f32, @floatFromInt(region.rect.x + region.rect.w)) * layout.w,
+ @as(f32, @floatFromInt(region.rect.y + region.rect.h)) * layout.h,
+ };
+ const joined = for (out[0..n]) |*other| {
+ // The same rows, a gap cell or two apart (a grip, the gap after
+ // it, its tag): one band.
+ const gap = 2 * layout.w + 0.5;
+ if (other[1] == rect[1] and other[3] == rect[3] and rect[0] <= other[2] + gap and other[0] <= rect[2] + gap) {
+ other.* = .{ @min(other[0], rect[0]), rect[1], @max(other[2], rect[2]), rect[3] };
+ break true;
+ }
+ } else false;
+ if (joined) continue;
+ if (n == out.len) {
+ const last = &out[n - 1];
+ last.* = .{ @min(last[0], rect[0]), @min(last[1], rect[1]), @max(last[2], rect[2]), @max(last[3], rect[3]) };
+ continue;
+ }
+ out[n] = rect;
+ n += 1;
+ }
+ return n;
+}
+
+const CursorBox = Post.Frame.Cursor;
+const max_cursors = 1 + pardes.MAX_PANES + pardes.MAX_TAG_LAYERS;
+
+/// Where the frame draws the focused caret, its top in grid rows: from its
+/// own springs (the quad's, while it moves or while a glide moves the text)
+/// or its cell; carried by the text's glide when its line rode it. The probe
+/// records it and the glide tests hold its invariants.
+fn caretRow(g: *const Gui, surface: *const pardes.Surface) ?f32 {
+ const chrome = &surface.chrome;
+ const cursor = surface.cursor orelse return null;
+ const quad = chrome.cursor_glide & 2 != 0 and (chrome.cursor_glide & 1 != 0 or g.glide.follow.offset != 0);
+ return if (quad) chrome.cursor_quad[1] - caretRide(g, surface) else @floatFromInt(cursor.y);
+}
+
+/// The rows a caret whose line rode the wheel's glide is drawn above its
+/// cell: the text's own offset, so it moves with its line as a glyph does
+/// (its springs landed on the cell, draw.glideCursor).
+fn caretRide(g: *const Gui, surface: *const pardes.Surface) f32 {
+ const glide = &g.glide;
+ if (!glide.caret_rides or glide.follow.offset == 0) return 0;
+ const cu = surface.cursor orelse return 0;
+ const x0 = glide.rect.x + config.GUTTER;
+ if (cu.x < x0 or cu.x >= x0 + glide.bw() or cu.y < glide.body_y or cu.y >= glide.body_y + glide.body_h) return 0;
+ return glide.follow.offset;
+}
+
+/// Every cursor on the frame where it is drawn, in window pixels: the grid's
+/// where no layer has its cell, and each layer's at that layer's pitch. A bar
+/// is an eighth of its cell wide, a block the whole cell.
+fn cursorBoxes(g: *const Gui, surface: *const pardes.Surface, layout: CellLayout, win_h: f32, out: *[max_cursors]CursorBox) usize {
+ const chrome = &surface.chrome;
+ const page = chrome.page orelse bg_default;
+ var n: usize = 0;
+ if (surface.cursor) |cursor| {
+ if (cursor.x < surface.cols and cursor.y < surface.rows and bodyLayerAt(surface, cursor.x, cursor.y) == null and tagLayerIn(surface.tagLayers(), cursor.x, cursor.y) == null) {
+ const cell = &surface.cells[@as(usize, cursor.y) * surface.cols + cursor.x];
+ const role = cellFontRole(cell);
+ const width: f32 = if (role == .tagline) @floatFromInt(g.tagline_width) else layout.w;
+ const height = std.math.clamp(if (role == .tagline) @as(f32, @floatFromInt(g.tagline_height)) else layout.h, 1.0, layout.h);
+ const x0 = @as(f32, @floatFromInt(cursor.x)) * layout.w;
+ const y0 = @as(f32, @floatFromInt(cursor.y)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(cursor.y, win_h, @intFromFloat(layout.h), @intFromFloat(height))));
+ out[n] = .{ .x0 = x0, .y0 = y0, .x1 = x0 + if (cursor.bar) @max(dp(1), width / 8.0) else width, .y1 = y0 + height, .rgb = cursorColor(chrome, cell, role), .text = page, .bar = cursor.bar };
+ n += 1;
+ }
+ }
+ for (surface.bodyLayers()) |*layer| {
if (layer.rows == 0) continue;
+ const cursor = layer.cursor orelse continue;
+ if (cursor.y >= layer.rows or cursor.x >= layer.cols) continue;
const left = @as(f32, @floatFromInt(layer.viewport.x)) * layout.w;
const bottom = @as(f32, @floatFromInt(layer.viewport.y + layer.viewport.h)) * layout.h;
- if (layer.cursor) |cursor| {
- if (!cursor.bar or cursor.y >= layer.rows or cursor.x >= layer.cols) continue;
- const top = layer.rowTop(cursor.y, layout.h, @floatFromInt(g.tagline_height));
- if (top >= bottom) continue;
- const height = layer.rowHeight(cursor.y, layout.h, @floatFromInt(g.tagline_height));
- const role: pardes.FontRole = if (cursor.y < layer.context_rows) .tagline else .body;
- const width: f32 = if (role == .tagline) @floatFromInt(g.tagline_width) else layout.w;
- const x = left + @as(f32, @floatFromInt(cursor.x)) * width;
- const cell = &layer.cells[@as(usize, cursor.y) * layer.cols + cursor.x];
- builder.addRect(x, top, x + @max(1, width / 8), @min(bottom, top + height), overlayRgb(cursorColor(core, cell, role)));
- }
- };
- if (transient_on) for (surface.tagLayers()) |*layer| {
- if (layer.cols == 0) continue;
+ const top = layer.rowTop(cursor.y, layout.h, @floatFromInt(g.tagline_height));
+ if (top >= bottom) continue;
+ const height = layer.rowHeight(cursor.y, layout.h, @floatFromInt(g.tagline_height));
+ const role: pardes.FontRole = if (cursor.y < layer.context_rows) .tagline else .body;
+ const width: f32 = if (role == .tagline) @floatFromInt(g.tagline_width) else layout.w;
+ const x = left + @as(f32, @floatFromInt(cursor.x)) * width;
+ const cell = &layer.cells[@as(usize, cursor.y) * layer.cols + cursor.x];
+ out[n] = .{ .x0 = x, .y0 = top, .x1 = x + if (cursor.bar) @max(dp(1), width / 8) else width, .y1 = @min(bottom, top + height), .rgb = cursorColor(chrome, cell, role), .text = page, .bar = cursor.bar };
+ n += 1;
+ }
+ for (surface.tagLayers()) |*layer| {
+ if (layer.rows == 0) continue;
const cursor = layer.cursor orelse continue;
- if (!cursor.bar or cursor.col >= layer.cols) continue;
+ if (cursor.x >= layer.cols or cursor.y >= layer.rows) continue;
const width: f32 = @floatFromInt(g.tagline_width);
const left = @as(f32, @floatFromInt(layer.viewport.x)) * layout.w;
const right = left + @as(f32, @floatFromInt(layer.viewport.w)) * layout.w;
- const x = left + @as(f32, @floatFromInt(cursor.col)) * width;
- if (x >= right) continue;
- const top = @as(f32, @floatFromInt(layer.viewport.y)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(layer.viewport.y, builder.win_h, g.cell_h, g.tagline_height, true)));
- builder.addRect(x, top, @min(right, x + @max(1, width / 8)), top + @as(f32, @floatFromInt(g.tagline_height)), overlayRgb(cursorColor(core, &layer.cells[cursor.col], .tagline)));
- };
- if (transient_on) appendTouchOverlay(g, &builder, debug_on);
+ // Past a full row's end the caret sits at the tag's right edge, as
+ // the grid's does (and the core's cursor box, draw.focusedCursorBox).
+ const x = @min(left + @as(f32, @floatFromInt(cursor.x)) * width, right - if (cursor.bar) @max(dp(1), width / 8) else width);
+ const y = layer.viewport.y + cursor.y;
+ const top = @as(f32, @floatFromInt(y)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(y, win_h, g.cell_h, g.tagline_height)));
+ out[n] = .{ .x0 = x, .y0 = top, .x1 = @min(right, x + if (cursor.bar) @max(dp(1), width / 8) else width), .y1 = top + @as(f32, @floatFromInt(g.tagline_height)), .rgb = cursorColor(chrome, &layer.cells[@as(usize, cursor.y) * layer.cols + cursor.x], .tagline), .text = page, .bar = cursor.bar };
+ n += 1;
+ }
+ return n;
+}
+
+/// The bar cursors as decor; a block cursor is its cell's own colours.
+fn cursorDecor(g: *Gui, gpa: std.mem.Allocator, surface: *const pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32) !void {
+ var boxes: [max_cursors]CursorBox = undefined;
+ for (boxes[0..cursorBoxes(g, surface, layout, win_h, &boxes)]) |box|
+ if (box.bar) try addDecor(g, gpa, box.x0, box.y0, box.x1, box.y1, box.rgb, 1, null, win_w, win_h);
+}
+
+/// The triangle overlay: the workspace pet and the touch debug view, over
+/// everything.
+fn buildOverlay(
+ g: *Gui,
+ core: ?*const pardes.Pardes,
+ surface: *const pardes.Surface,
+ sw: u32,
+ sh: u32,
+ debug_on: bool,
+) u32 {
+ if (g.overlay_vertices.len == 0 or sw == 0 or sh == 0) return 0;
+ var builder = OverlayBuilder{ .vertices = g.overlay_vertices, .win_w = @floatFromInt(sw), .win_h = @floatFromInt(sh) };
+ appendWorkspacePet(g, core, surface, &builder);
+ appendCursorGlide(g, surface, &builder);
+ appendTouchOverlay(g, &builder, debug_on);
return @intCast(builder.len);
}
+/// G3: the focused cursor while it glides or blinks, its quad from the core
+/// (Chrome.cursor_quad, grid cells) in its cursor colour; a little less than
+/// solid, so the glyphs it passes over stay legible.
+fn appendCursorGlide(g: *Gui, surface: *const pardes.Surface, builder: *OverlayBuilder) void {
+ const chrome = &surface.chrome;
+ if (g.cursor_quad_alpha <= 0.001) return;
+ const layout = fixedCellLayout(g);
+ const ride = caretRide(g, surface);
+ if (ride != 0) {
+ // Carried past the body's edge with its line: clipped as the text is.
+ const mid = chrome.cursor_quad[1] - ride + 0.5;
+ const top: f32 = @floatFromInt(g.glide.body_y);
+ if (mid < top or mid > top + @as(f32, @floatFromInt(g.glide.body_h))) return;
+ }
+ var px: [4][2]f32 = undefined;
+ var centre: [2]f32 = .{ 0, 0 };
+ for (&px, 0..) |*point, i| {
+ point.* = .{ chrome.cursor_quad[i * 2] * layout.w, (chrome.cursor_quad[i * 2 + 1] - ride) * layout.h };
+ centre[0] += point[0] / 4;
+ centre[1] += point[1] / 4;
+ }
+ // Its colour: the cursor the cells would draw nearest the quad.
+ var boxes: [max_cursors]CursorBox = undefined;
+ var rgb: [3]u8 = chrome.fg orelse fg_default;
+ var nearest: f32 = std.math.inf(f32);
+ for (boxes[0..cursorBoxes(g, surface, layout, builder.win_h, &boxes)]) |box| {
+ const dx = (box.x0 + box.x1) / 2 - centre[0];
+ const dy = (box.y0 + box.y1) / 2 - centre[1];
+ if (dx * dx + dy * dy < nearest) {
+ nearest = dx * dx + dy * dy;
+ rgb = box.rgb;
+ }
+ }
+ const color: OverlayColor = .{ .r = @as(f32, @floatFromInt(rgb[0])) / 255, .g = @as(f32, @floatFromInt(rgb[1])) / 255, .b = @as(f32, @floatFromInt(rgb[2])) / 255, .a = g.cursor_quad_alpha };
+ builder.addTri(px[0][0], px[0][1], px[1][0], px[1][1], px[2][0], px[2][1], color);
+ builder.addTri(px[0][0], px[0][1], px[2][0], px[2][1], px[3][0], px[3][1], color);
+}
+
fn appendWorkspacePet(g: *Gui, core: ?*const pardes.Pardes, surface: *const pardes.Surface, builder: *OverlayBuilder) void {
const p = core orelse return;
- const kind: pet.Kind = @enumFromInt(@intFromEnum(p.settings.pet));
+ const kind: pet.Kind = @fromBackingInt(@intCast(@backingInt(p.settings.pet)));
if (kind == .off or surface.rows == 0 or surface.cols == 0) {
g.pet_state = .{};
return;
}
// Read only the rendered global row. No pane/column tags, status text or
- // mouse targets are changed, and editing the workspace parks the pet.
+ // mouse targets are changed; editing the workspace tag leaves it be.
var occupied: usize = 0;
for (surface.cells[0..surface.cols], 0..) |*cell, i| {
if (cellCodepoint(cell) != ' ') occupied = i + 1;
}
- const editing = p.topbar_col != null and p.header_column == null;
- const band_top: f32 = @floatFromInt(taglineBandOffset(0, builder.win_h, g.cell_h, g.tagline_height, true));
+ const band_top: f32 = @floatFromInt(taglineBandOffset(0, builder.win_h, g.cell_h, g.tagline_height));
const region = if (occupied >= surface.cols) null else pet.lane(
occupied,
@floatFromInt(g.tagline_width),
builder.win_w,
band_top,
@floatFromInt(g.tagline_height),
- editing,
);
// SDL's regular pump already wakes at least every 16 ms. Quantization in
// sample keeps this independent of input, render rate and scene effects,
@@ -6586,16 +10657,24 @@ fn appendWorkspacePet(g: *Gui, core: ?*const pardes.Pardes, surface: *const pard
const pose = g.pet_state.sample(kind, c.SDL_GetTicks(), region) orelse return;
const ink = overlayRgb(p.chromeTheme().tag_fg);
const eye = overlayRgb(p.chromeTheme().tag_bg);
+ // Behind the cursor: the overlay is over the cells, so the pixels a
+ // cursor covers are left out.
+ var boxes: [max_cursors]CursorBox = undefined;
+ const cursors = boxes[0..cursorBoxes(g, surface, fixedCellLayout(g), builder.win_h, &boxes)];
for (0..pet.height) |y| for (0..pet.width) |x| {
const color = pet.pixel(kind, pose, x, y);
if (color == 0) continue;
const x0 = pose.x + @as(f32, @floatFromInt(x)) * pose.scale;
const y0 = pose.y + @as(f32, @floatFromInt(y)) * pose.scale;
+ const covered = for (cursors) |box| {
+ if (x0 < box.x1 and x0 + pose.scale > box.x0 and y0 < box.y1 and y0 + pose.scale > box.y0) break true;
+ } else false;
+ if (covered) continue;
builder.addRect(x0, y0, x0 + pose.scale, y0 + pose.scale, if (color == 2) eye else ink);
};
}
-test "pet overlay stays beyond workspace text and vanishes while its tag is edited" {
+test "pet overlay stays beyond workspace text and keeps going while its tag is edited" {
std.testing.refAllDecls(pet);
const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
defer core.deinit();
@@ -6622,40 +10701,20 @@ test "pet overlay stays beyond workspace text and vanishes while its tag is edit
try std.testing.expect(x >= 20 * 8 - 0.01);
try std.testing.expect(y >= 0 and y < 20);
}
- core.topbar_col = 0;
- core.header_column = null;
+ const before = g.pet_state;
+ pardes.tagline.enterHeader(core, null);
builder.len = 0;
appendWorkspacePet(&g, core, &surface, &builder);
- try std.testing.expectEqual(@as(usize, 0), builder.len);
+ try std.testing.expect(builder.len > 0);
+ try std.testing.expectEqual(before.tick, g.pet_state.tick);
+ try std.testing.expectEqual(before.x, g.pet_state.x);
}
-fn cursorColor(core: ?*const pardes.Pardes, cell: *const pardes.Cell, role: pardes.FontRole) [3]u8 {
- if (core) |p| return if (role == .tagline) switch (cell.style.fg) {
- .rgb => |rgb| rgb,
- else => p.chromeTheme().tag_fg,
- } else p.theme().fg orelse fg_default;
- return switch (cell.style.fg) {
+fn cursorColor(chrome: *const pardes.Chrome, cell: *const pardes.Cell, role: pardes.FontRole) [3]u8 {
+ return if (role == .tagline) switch (cell.style.fg) {
.rgb => |rgb| rgb,
- .index => |index| palColor(index),
- // Detached frames carry explicit page backgrounds but blank cells need
- // not carry foreground ink. Keep their insertion caret visible too.
- .default => switch (cell.style.bg) {
- .rgb => |rgb| if ((@as(u16, rgb[0]) * 3 + @as(u16, rgb[1]) * 6 + rgb[2]) / 10 > 140)
- .{ 32, 32, 32 }
- else
- fg_default,
- else => fg_default,
- },
- };
-}
-
-test "detached insertion caret contrasts with blank light and dark pages" {
- var cell: pardes.Cell = .{ .default = false, .style = .{ .bg = .{ .rgb = .{ 248, 246, 237 } } } };
- try std.testing.expectEqual([3]u8{ 32, 32, 32 }, cursorColor(null, &cell, .body));
- cell.style.bg = .{ .rgb = .{ 24, 28, 32 } };
- try std.testing.expectEqual(fg_default, cursorColor(null, &cell, .body));
- cell.style.fg = .{ .rgb = .{ 122, 188, 160 } };
- try std.testing.expectEqual([3]u8{ 122, 188, 160 }, cursorColor(null, &cell, .body));
+ else => chrome.tag_fg,
+ } else chrome.fg orelse fg_default;
}
fn overlayRgb(rgb: [3]u8) OverlayColor {
@@ -6667,154 +10726,6 @@ fn overlayRgb(rgb: [3]u8) OverlayColor {
};
}
-fn cellBackgroundIs(cell: *const pardes.Cell, rgb: [3]u8) bool {
- return !cell.default and switch (cell.style.bg) {
- .rgb => |bg| std.mem.eql(u8, &bg, &rgb),
- else => false,
- };
-}
-
-// The canonical surface still owns scrollbar positions and hit targets. Only
-// their pixel ink is inset here; no layout, selection or mouse coordinates move.
-fn appendPaneChrome(
- core: *const pardes.Pardes,
- surface: *const pardes.Surface,
- layout: CellLayout,
- builder: *OverlayBuilder,
-) void {
- const chrome = core.chromeTheme();
- const page = overlayRgb(core.theme().bg orelse bg_default);
- for (core.panes, core.rects) |slot, r| {
- if (slot == null or r.w <= config.GUTTER or r.h <= pardes.BOX_H) continue;
- if (@as(u32, r.x) + r.w > surface.cols or @as(u32, r.y) + r.h > surface.rows) continue;
- const tag_y = if (core.settings.tag_bottom) r.y + r.h - pardes.BOX_H else r.y;
- const body_y = if (core.settings.tag_bottom) r.y else r.y + pardes.BOX_H;
- const body_end = body_y + r.h - pardes.BOX_H;
- const x0 = @as(f32, @floatFromInt(r.x)) * layout.w;
- const x1 = x0 + @as(f32, @floatFromInt(r.w)) * layout.w;
- const tag_cells = surface.cells[@as(usize, tag_y) * surface.cols + r.x + pardes.TAG_TEXT_INSET ..][0 .. r.w - pardes.TAG_TEXT_INSET];
- const tag_visible = for (tag_cells) |*cell| {
- if (cellFontRole(cell) != .tagline) break false;
- } else true;
- if (tag_visible) {
- const rule_y = @as(f32, @floatFromInt(tag_y + @as(u16, if (core.settings.tag_bottom) 0 else 1))) * layout.h;
- builder.addRect(x0, rule_y - @as(f32, if (core.settings.tag_bottom) 0 else 1), x1, rule_y + @as(f32, if (core.settings.tag_bottom) 1 else 0), overlayRgb(chrome.border));
- }
-
- // Do not paint over resize previews or debug text occupying the rail.
- var thumb_start: ?u16 = null;
- var thumb_end: u16 = body_y;
- var row = body_y;
- while (row < body_end) : (row += 1) {
- const cell = &surface.cells[@as(usize, row) * surface.cols + r.x];
- if (cell.printableAscii() != ' ') break;
- if (cellBackgroundIs(cell, chrome.scroll_thumb)) {
- if (thumb_start == null) thumb_start = row;
- thumb_end = row + 1;
- } else if (!cellBackgroundIs(cell, chrome.scroll_track)) break;
- }
- if (row != body_end) continue;
- const y0 = @as(f32, @floatFromInt(body_y)) * layout.h;
- const y1 = @as(f32, @floatFromInt(body_end)) * layout.h;
- builder.addRect(x0, y0, x0 + layout.w, y1, page);
- appendSquareRail(builder, x0, y0, y1, layout.w, false, overlayRgb(chrome.scroll_track));
- if (thumb_start) |first| {
- const thumb_y0 = @as(f32, @floatFromInt(first)) * layout.h;
- const thumb_y1 = @as(f32, @floatFromInt(thumb_end)) * layout.h;
- appendSquareRail(builder, x0, thumb_y0, thumb_y1, layout.w, true, overlayRgb(chrome.scroll_thumb));
- }
- }
- appendColumnSpines(core, surface.rows, layout, builder);
-}
-
-// Tag handles use the canonical physical cells, including detached frames.
-// Their tag text begins at the layer viewport and may use a narrower font.
-fn appendTagGrips(g: *const Gui, surface: *const pardes.Surface, layout: CellLayout, builder: *OverlayBuilder) void {
- if (g.tagline_height < 6 or g.tagline_width < 3) return;
- for (surface.tagLayers()) |layer| {
- if (layer.cols == 0 or layer.kind != .pane or layer.viewport.x < pardes.TAG_TEXT_INSET) continue;
- const x = layer.viewport.x - pardes.TAG_TEXT_INSET;
- const y = layer.viewport.y;
- if (x >= surface.cols or y >= surface.rows) continue;
- const cell = &surface.cells[@as(usize, y) * surface.cols + x];
- if (cell.default or cell.printableAscii() != ' ') continue;
- const rgb = switch (cell.style.fg) {
- .rgb => |rgb| rgb,
- else => continue,
- };
- const center_x = (@as(f32, @floatFromInt(x)) + @as(f32, @floatFromInt(config.GUTTER)) / 2) * layout.w;
- const center_y = @as(f32, @floatFromInt(y)) * layout.h + @as(f32, @floatFromInt(taglineBandOffset(y, builder.win_h, g.cell_h, g.tagline_height, true))) + @as(f32, @floatFromInt(g.tagline_height)) / 2;
- const half_w = @max(1, @min(3, layout.w - 2));
- builder.addRect(@floor(center_x - half_w), @floor(center_y - 2), @floor(center_x + half_w), @floor(center_y - 1), overlayRgb(rgb));
- builder.addRect(@floor(center_x - half_w), @floor(center_y + 1), @floor(center_x + half_w), @floor(center_y + 2), overlayRgb(rgb));
- }
-}
-
-test "column grips stay unmarked while pane marks retain physical centering" {
- var g: Gui = undefined;
- g.tagline_height = 12;
- g.tagline_width = 6;
- g.cell_h = 20;
- var cells: [80]pardes.Cell = @splat(.{ .default = false, .style = .{ .fg = .{ .rgb = .{ 100, 120, 140 } } } });
- var surface: pardes.Surface = .{ .cols = 20, .rows = 4, .cells = &cells };
- surface.tag_layers[0] = .{ .kind = .column, .viewport = .{ .x = 8, .y = 1, .w = 13, .h = 1 }, .cols = 20 };
- surface.tag_layers[1] = .{ .kind = .pane, .viewport = .{ .x = 8, .y = 3, .w = 13, .h = 1 }, .cols = 20 };
- var vertices: [24]OverlayVertex = undefined;
- var builder: OverlayBuilder = .{ .vertices = &vertices, .win_w = 200, .win_h = 80 };
- appendTagGrips(&g, &surface, .{ .w = 10, .h = 20, .x_off = 0, .y_off = 0 }, &builder);
- try std.testing.expectEqual(@as(usize, 12), builder.len);
- try std.testing.expectApproxEqAbs(@as(f32, 57.0 / 200.0 * 2.0 - 1.0), vertices[0].x, 0.0001);
-}
-
-fn appendSquareRail(builder: *OverlayBuilder, x: f32, y0: f32, y1: f32, cell_w: f32, thumb: bool, color: OverlayColor) void {
- const width = @min(cell_w, if (thumb) @max(2, @floor(cell_w * 0.5)) else 2);
- builder.addRect(x, y0, x + width, y1, color);
-}
-
-fn appendColumnSpines(core: *const pardes.Pardes, rows: u16, layout: CellLayout, builder: *OverlayBuilder) void {
- const y0 = @as(f32, @floatFromInt(pardes.TOPBAR_H)) * layout.h;
- const y1 = @as(f32, @floatFromInt(rows)) * layout.h;
- if (y1 <= y0) return;
- // A single boundary spans all panes, including their tags. Its left edge
- // agrees with the square scroll markers and existing move-box hit area.
- for (core.col_x[0..core.ncol], core.col_w[0..core.ncol]) |col, width| {
- if (width == 0) continue;
- const x = @as(f32, @floatFromInt(col)) * layout.w;
- builder.addRect(x, y0, x + 1, y1, overlayRgb(core.chromeTheme().border));
- }
-}
-
-test "square scroll markers share the column edge and have no rounded end inset" {
- var vertices: [12]OverlayVertex = undefined;
- var builder: OverlayBuilder = .{ .vertices = &vertices, .win_w = 800, .win_h = 480 };
- appendSquareRail(&builder, 400, 40, 480, 10, false, overlayRgb(.{ 40, 40, 40 }));
- appendSquareRail(&builder, 400, 80, 160, 10, true, overlayRgb(.{ 100, 100, 100 }));
- try std.testing.expectEqual(@as(usize, 12), builder.len);
- try std.testing.expectEqual(vertices[0].x, vertices[6].x);
- try std.testing.expectApproxEqAbs(@as(f32, 1 - 80.0 / 480.0 * 2), vertices[6].y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 1 - 160.0 / 480.0 * 2), vertices[8].y, 0.0001);
- try std.testing.expectApproxEqAbs(@as(f32, 5.0 / 800.0 * 2), vertices[7].x - vertices[6].x, 0.0001);
-}
-
-test "column spines remain continuous across every pane tag and body" {
- const core = try pardes.Pardes.init(std.testing.allocator, .{ .cols = 80, .rows = 24 });
- defer core.deinit();
- _ = try core.newShell(1, "");
- try std.testing.expect(pardes.layout.splitColumn(core, 0, 1, false));
- pardes.test_api.sync(core);
- var vertices: [12]OverlayVertex = undefined;
- var builder: OverlayBuilder = .{ .vertices = &vertices, .win_w = 800, .win_h = 480 };
- appendColumnSpines(core, 24, .{ .w = 10, .h = 20, .x_off = 0, .y_off = 0 }, &builder);
- try std.testing.expectEqual(@as(usize, 12), builder.len);
- for (0..2) |col| {
- const first = vertices[col * 6];
- const bottom = vertices[col * 6 + 2];
- try std.testing.expectApproxEqAbs(@as(f32, 1 - 20.0 / 480.0 * 2), first.y, 0.0001);
- try std.testing.expectEqual(@as(f32, -1), bottom.y);
- try std.testing.expectApproxEqAbs(@as(f32, @floatFromInt(core.col_x[col])) * 10.0 / 800.0 * 2 - 1, first.x, 0.0001);
- }
-}
-
fn appendTouchOverlay(g: *Gui, builder: *OverlayBuilder, debug_on: bool) void {
if (!debug_on) {
g.touch.click_flash_frames = 0;
@@ -6882,7 +10793,8 @@ fn uploadOverlayGpu(g: *Gui, cmd: *c.SDL_GPUCommandBuffer, vertex_count: u32) bo
}
fn pushLayerOpacity(cmd: *c.SDL_GPUCommandBuffer, pass: ?*c.SDL_GPURenderPass, opacity: f32) void {
- const uniforms = [4]f32{ opacity, 0, 0, 0 };
+ var uniforms = [4]f32{ opacity, 0, 0, 0 } ++ @as([12]f32, @splat(0));
+ uniforms[4..].* = cell_decor.uniforms;
c.SDL_PushGPUFragmentUniformData(cmd, 0, &uniforms, @sizeOf(@TypeOf(uniforms)));
// The source alpha is geometric/image coverage, not window opacity. Its
// alpha contribution is multiplied by this constant separately, so a
@@ -7087,32 +10999,6 @@ fn miniGlyph(ch: u8) [5]u8 {
};
}
-fn effCp(key: vaxis.Key) u21 {
- if (key.text) |t| {
- const view = std.unicode.Utf8View.init(t) catch return key.codepoint;
- var it = view.iterator();
- if (it.nextCodepoint()) |cp| {
- if (it.nextCodepoint() == null) return cp;
- }
- }
- return key.shifted_codepoint orelse key.codepoint;
-}
-
-fn mapKey(cp: u21) u21 {
- return switch (cp) {
- vaxis.Key.up => pardes.Key.up,
- vaxis.Key.down => pardes.Key.down,
- vaxis.Key.left => pardes.Key.left,
- vaxis.Key.right => pardes.Key.right,
- vaxis.Key.home => pardes.Key.home,
- vaxis.Key.end => pardes.Key.end,
- vaxis.Key.page_up => pardes.Key.page_up,
- vaxis.Key.page_down => pardes.Key.page_down,
- vaxis.Key.delete => pardes.Key.delete,
- else => cp,
- };
-}
-
fn envU16(env: *std.process.Environ.Map, name: []const u8) ?u16 {
const raw = env.get(name) orelse return null;
return std.fmt.parseInt(u16, raw, 10) catch null;
@@ -7120,13 +11006,14 @@ fn envU16(env: *std.process.Environ.Map, name: []const u8) ?u16 {
test "compact body layer rendering fills recovered rows and clips the final glyph" {
var g: Gui = undefined;
+ g.words = .{};
g.cell_w = 10;
g.cell_h = 20;
g.tagline_width = 6;
g.tagline_height = 12;
g.space_slot = .{ .u = 0, .v = 0 };
var cells: [24]pardes.Cell = @splat(.{});
- var layer: pardes.BodyLayer = .{
+ var layer: pardes.Layer = .{
.viewport = .{ .x = 3, .y = 2, .w = 2, .h = 5 },
.cols = 2,
.rows = 12,
@@ -7159,13 +11046,14 @@ test "compact body layer rendering fills recovered rows and clips the final glyp
test "compact tag layers fill available width and clip at their physical edge" {
var g: Gui = undefined;
+ g.words = .{};
g.cell_w = 10;
g.cell_h = 20;
g.tagline_width = 6;
g.tagline_height = 12;
g.space_slot = .{ .u = 0, .v = 0 };
var cells: [6]pardes.Cell = @splat(.{});
- const layer: pardes.TagLayer = .{ .kind = .pane, .id = 0, .serial = 7, .viewport = .{ .x = 2, .y = 3, .w = 3, .h = 1 }, .cols = 6, .cells = &cells, .bg = .{ 20, 30, 40 } };
+ const layer: pardes.Layer = .{ .kind = .pane, .id = 0, .serial = 7, .viewport = .{ .x = 2, .y = 3, .w = 3, .h = 1 }, .cols = 6, .rows = 1, .cells = &cells, .bg = .{ 20, 30, 40 } };
var instances: [8]CellInstance = undefined;
var next: u32 = 0;
emitTagLayer(&g, &instances, &next, &layer, 100, 100, null, Ground.opaqueRgb(bg_default), false, false);