diff options
| author | Gabriel Schneider <[email protected]> | 2026-10-28 20:48:35 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-10-28 21:06:05 -0300 |
| commit | a48a825b06cc45947adaecf42073ed86af8b7a2d (patch) | |
| tree | 509cacc7f59b947c37d42b5236e5b51f9e6181e6 /src | |
| parent | be98a09274b597649fe8a53eb3ce43f7151201d7 (diff) | |
| download | pardes-a48a825b06cc45947adaecf42073ed86af8b7a2d.tar.gz pardes-a48a825b06cc45947adaecf42073ed86af8b7a2d.zip | |
ghostty 1.4.0: pin the release (83fb9562), six days past the main commit we had; vaxis and uucode stay on the commits it pins
What reaches pardes: ED 3 now flags tracked pins on the history it erases `garbage` and takes away the kitty placements there (they used to come back at the pane's top), a cancelled or aborted APC runs nothing, and scrollClear keeps the cursor's style and hyperlink valid when it prunes the cursor's page. No API pardes calls changed.
ED 3, decided by terminal.zig's own rule for rows that are gone: an edited copy or a selection (vsel, msel, the extra ranges) whose top row ED 3 erased goes, rather than being clamped to row 0. The undo history keeps its copy, at the top. `partial_clear_history` asserts it; MarkedHandler.lost and CommandOutput.whole say what ED 3 does now.
Tests: ED 3 takes away a placement in the history it erases; a finished command's output erased by a later ED 3 is not whole and has no text; a selection on an erased row goes, one on the screen stays.
CHANGELOG; docs/render-pipeline.md and Post.zig name ghostty 1.4.0 (its shadertoy Uniforms are unchanged).
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'src')
| -rw-r--r-- | src/CHANGELOG.md | 9 | ||||
| -rw-r--r-- | src/gui/Post.zig | 2 | ||||
| -rw-r--r-- | src/terminal.zig | 135 |
3 files changed, 139 insertions, 7 deletions
diff --git a/src/CHANGELOG.md b/src/CHANGELOG.md index fc8ede3b..2144f710 100644 --- a/src/CHANGELOG.md +++ b/src/CHANGELOG.md @@ -2,6 +2,15 @@ ## Unreleased +- ghostty moves to its 1.4.0 release (from a main commit six days before + it; libvaxis and uucode stay on the commits it pins). A terminal's + `clear` (ED 3) now takes away the kitty images placed on the history it + erases, where they used to come back at the top of the pane; a + cancelled kitty command (CAN, SUB) no longer runs; and a command whose + output ED 3 erased after it finished reads as not whole, with no text, + instead of the rows that took its place. An edited copy or a selection + whose top row ED 3 erased now goes, as the copy already did when its + rows were pruned, instead of moving to the top. - Window mode (Ctrl-w, SPC w) takes `d` and `c`: `d` is Del on the outlined pane, asking k or j between two panes as SPC d does, and the outline moves to the pane that took the rows; `c` collapses it. The mode diff --git a/src/gui/Post.zig b/src/gui/Post.zig index 17e8d7e9..a79d9f0c 100644 --- a/src/gui/Post.zig +++ b/src/gui/Post.zig @@ -577,7 +577,7 @@ pub fn deinit(post: *Post, gpa: std.mem.Allocator, device: *c.SDL_GPUDevice) voi for (post.ping) |texture| if (texture) |t| c.SDL_ReleaseGPUTexture(device, t); } -/// ghostty 1.3.2's Uniforms (src/renderer/shadertoy.zig), copied: the offsets +/// ghostty 1.4.0's Uniforms (src/renderer/shadertoy.zig), copied: the offsets /// ours must match. Its last two names are swapped against its own GLSL. const GhosttyUniforms = extern struct { resolution: [3]f32 align(16), diff --git a/src/terminal.zig b/src/terminal.zig index 755fde6c..77ee9b44 100644 --- a/src/terminal.zig +++ b/src/terminal.zig @@ -54,9 +54,11 @@ pub const MarkedHandler = if (enabled) struct { out_start: ?*ghostty_vt.Pin = null, out_end: ?*ghostty_vt.Pin = null, /// The running command's output was erased under it -- a clear, ED 3, - /// a reset -- so the pins no longer span what it printed: ED 3 moves - /// a pin to the next page without flagging it `garbage` - /// (PageList.erasePage). + /// a reset -- so the pins no longer span what it printed. ED 3 flags a + /// pin on an erased history row `garbage` (ghostty 1.4), but `pinTop` + /// re-pins the start at the screen's top, so the flag is gone with the + /// old pin: this remembers it, as it does for a reset or a pin that + /// could not be made. lost: bool = false, /// The newest command to end: which one, and its status if given. @@ -950,6 +952,11 @@ fn ingestWithPositions(pane: *Pane, bytes: []const u8) void { } } const overlay = groups[0].overlay; + // Where the live pane's own selections sit in `positions`: one whose + // row the program erased goes (below), as the edited copy does. + const vsel_at: ?usize = if (pane.body.vsel.active) 1 else null; + const msel_at: ?usize = if (pane.body.msel.active) npositions else null; + const sels_at = npositions + @as(usize, if (pane.body.msel.active) 2 else 0); var extra: [panes.Text.max_selections * 2 + 4]*i32 = undefined; var nextra: usize = 0; if (pane.body.msel.active) { @@ -1018,6 +1025,24 @@ fn ingestWithPositions(pane: *Pane, bytes: []const u8) void { if (span.end.pin) |pin| owner.untrackPin(pin); } } + // The rule above for the copy holds for the selections: one whose row + // is gone (ED 3 erased its history row, which ghostty flags `garbage`) + // goes too, rather than being clamped to the top. + const erased = struct { + fn at(owner: ?*ghostty_vt.PageList, all: []const PositionPin, index: usize) bool { + if (owner == null) return false; + const pin = all[index].row.pin orelse return false; + return pin.garbage; + } + }.at; + const vsel_lost = if (vsel_at) |i| + erased(alive, positions[0..npositions], i) or (copy_lost and positions[i].edit_row != null) + else + false; + const msel_lost = if (msel_at) |i| erased(alive, positions[0..npositions], i) or erased(alive, positions[0..npositions], i + 1) else false; + var sels_keep: [panes.Text.max_selections]bool = undefined; + for (0..pane.body.nsel) |i| sels_keep[i] = !(erased(alive, positions[0..npositions], sels_at + 2 * i) or + erased(alive, positions[0..npositions], sels_at + 2 * i + 1)); for ([_][]PositionPin{ positions[0..npositions], pointer_positions orelse &.{} }) |batch| for (batch) |position| { var row = pinnedRow(alive, position.row); if (position.overlay) |edit| { @@ -1038,6 +1063,25 @@ fn ingestWithPositions(pane: *Pane, bytes: []const u8) void { pane.clearPointerSelection(button); pane.sel[button].state = .none; }; + if (vsel_lost) { + pane.body.vsel.active = false; + moved = true; + } + if (msel_lost) { + pane.body.msel.active = false; + moved = true; + } + if (pane.body.nsel > 0) { + var kept: u16 = 0; + for (0..pane.body.nsel) |i| if (sels_keep[i]) { + pane.body.sels[kept] = pane.body.sels[i]; + kept += 1; + }; + if (kept != pane.body.nsel) { + moved = true; + if (kept == 0) pane.body.dropSels() else pane.body.nsel = kept; + } + } if (copy_lost) if (pane.ovl) |copy| { pane.gpa.free(copy.text); pane.ovl = null; @@ -1110,9 +1154,10 @@ pub const CommandOutput = struct { text: [:0]const u8, /// Whether `text` starts where the command did. It does not when that /// start is not there to read: cut off by `max_rows`, scrolled out of - /// the history (ghostty moved the pin to the oldest row it kept and - /// flagged it `garbage`), erased under it (`MarkedHandler.lost`), or - /// never pinned (a C or D that came on the alternate screen). + /// the history or erased from it by ED 3 (ghostty flags the pin + /// `garbage`; an erased end leaves no text at all), erased under it + /// while it ran (`MarkedHandler.lost`), or never pinned (a C or D that + /// came on the alternate screen). whole: bool, }; @@ -2979,6 +3024,84 @@ test "a terminal's kitty graphics image is drawn where its program placed it, an try std.testing.expectEqual(@as(usize, 0), imagePlaces(s).len); } +/// `n` line breaks: enough of them push the screen's rows into history. +fn lineBreaks(comptime n: usize) [2 * n]u8 { + var out: [2 * n]u8 = undefined; + for (0..n) |i| out[2 * i ..][0..2].* = "\r\n".*; + return out; +} + +test "ED 3 takes away a kitty placement whose row it erased: it never comes back at the top" { + if (comptime !images_enabled) return error.SkipZigTest; + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .cols = 80, .rows = 24, .shells = 1 }); + defer p.deinit(); + p.native_images = true; + p.update(.{ .resize = .{ .cols = 80, .rows = 24, .cell_pixels = .{ .w = 10, .h = 20 } } }); + var frame = std.heap.ArenaAllocator.init(gpa); + defer frame.deinit(); + const pane = p.panes[0].?; + pane.body.mode = .tty; + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[1;1H" ++ kittyTransmit("c=2,r=1") } }); + const storage = &pane.terminal.?.vt.screens.active.kitty_images; + try std.testing.expectEqual(@as(usize, 1), storage.placements.count()); + // Scrolled into the history, it is not on screen; `clear` (ED 2 then + // ED 3) erases that history and the placement with it. + p.update(.{ .output = .{ .pane = 0, .bytes = &lineBreaks(40) } }); + var s = try p.render(frame.allocator()); + try std.testing.expectEqual(@as(usize, 0), imagePlaces(s).len); + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[H\x1b[2J\x1b[3J" } }); + try std.testing.expectEqual(@as(usize, 0), storage.placements.count()); + _ = frame.reset(.retain_capacity); + s = try p.render(frame.allocator()); + try std.testing.expectEqual(@as(usize, 0), imagePlaces(s).len); +} + +test "a finished command's output erased by a later ED 3 is not called whole, and no rows stand in for it" { + if (comptime !enabled) return error.SkipZigTest; + const gpa = std.testing.allocator; + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 6 }); + defer p.deinit(); + const pane = p.panes[0].?; + const prompt = "\x1b]133;A;cl=line;aid=pardes\x07$ \x1b]133;B;aid=pardes\x07"; + p.update(.{ .output = .{ .pane = 0, .bytes = prompt ++ "\r\n\x1b]133;C;aid=pardes\x07printed\r\n\x1b]133;D;0;aid=pardes\x07" ++ prompt } }); + const before = try commandOutput(pane, gpa, 100); + defer gpa.free(before.text); + try std.testing.expect(before.whole); + try std.testing.expect(std.mem.startsWith(u8, before.text, "printed")); + // The command's rows go into the history, and ED 3 erases them: its + // pins are `garbage` now (ghostty 1.4), not moved to the screen's top, + // where another program's text would be read as its output. + p.update(.{ .output = .{ .pane = 0, .bytes = &lineBreaks(20) } }); + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[3J" } }); + const after = try commandOutput(pane, gpa, 100); + defer gpa.free(after.text); + try std.testing.expect(!after.whole); + try std.testing.expectEqualStrings("", after.text); +} + +test "a selection whose row ED 3 erased goes; one on the screen stays" { + if (comptime !enabled) return error.SkipZigTest; + const gpa = std.testing.allocator; + for ([_]bool{ true, false }) |in_history| { + const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 6 }); + defer p.deinit(); + const pane = p.panes[0].?; + pane.body.mode = .tty; + p.update(.{ .output = .{ .pane = 0, .bytes = &lineBreaks(20) } }); + pane.body.mode = .normal; + const pages = &pane.terminal.?.vt.screens.active.pages; + const top: i32 = @intCast(pages.total_rows - pane.rows); + const row: i32 = if (in_history) top - 3 else top + 2; + pane.body.vsel = .{ .active = true, .row = row, .col = 1 }; + pane.body.msel = .{ .active = true, .r0 = row, .r1 = row }; + p.update(.{ .output = .{ .pane = 0, .bytes = "\x1b[3J" } }); + try std.testing.expectEqual(!in_history, pane.body.vsel.active); + try std.testing.expectEqual(!in_history, pane.body.msel.active); + if (!in_history) try std.testing.expectEqual(@as(i32, 2), pane.body.vsel.row); + } +} + test "a virtual kitty placement shows through its placeholder cells, which draw no text" { if (comptime !images_enabled) return error.SkipZigTest; const gpa = std.testing.allocator; |
