summaryrefslogtreecommitdiff
path: root/src/gui/gui.zig
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 06:25:57 -0300
committerGabriel Schneider <[email protected]>2026-10-30 12:45:02 -0300
commitcb2688602b3f668790a9c35890973af80143697f (patch)
tree384f147de8b8971471b59ed29879ede6e35a1ea2 /src/gui/gui.zig
parent11e67e636b39b9b2901ec5cc49a13a012088650f (diff)
downloadpardes-cb2688602b3f668790a9c35890973af80143697f.tar.gz
pardes-cb2688602b3f668790a9c35890973af80143697f.zip
gui: the window a replica client (pardes-gui --attach=<socket>:<name> and <host>:<name>, as the tty's, far through ssh as amort's: its blobs by hash and its stream in zstd) and a window session serving replicas (a terminal's client or a window's): the client feeds its replica what its window does, read over its own view (views.within) and applied after, draws its view between steps, takes the stream on its own reader and rejoins as the tty's does (replica.Link, the client's half shared with it, the far path's Have with it); the session takes clients at its step boundary, one person's input a wait, a client's view no window of its own, its font and opacity answers taped; a client says its frontend first (Event.frontend, in wire 16 beside the far word) and the tty and window builds step alike (one desktop semantics: each has the other's words, which a view takes by its own frontend, builtins.registry.here); a check asked 300 ms after the last input and check, not per wake; test/daemon.py --window-clients
Co-Authored-By: Claude Opus 5.5 <[email protected]>
Diffstat (limited to 'src/gui/gui.zig')
-rw-r--r--src/gui/gui.zig573
1 files changed, 525 insertions, 48 deletions
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index a88a7335..f62871c4 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -24,6 +24,8 @@ const ninep_io = @import("../9p_io.zig");
const daemon = @import("../daemon.zig");
const upgrade = @import("../upgrade.zig");
+const replica = @import("../replica.zig");
+const wire = @import("../detached/wire.zig");
const tracy = @import("../tracy.zig");
pub const c = @import("gui_c"); // SDL3 and font.h, translated by build.zig
@@ -671,24 +673,29 @@ test "closing tombstone overlays but never owns canonical cells" {
}
fn updateCoreResize(core: *pardes.Pardes, cols: u16, rows: u16, cell_w: u32, cell_h: u32, tag_w: u32, tag_h: u32) bool {
+ core.update(resizeOf(core, cols, rows, cell_w, cell_h, tag_w, tag_h) orelse return false);
+ return true;
+}
+
+/// The resize a window of `cols` by `rows` cells of these sizes is to the
+/// live view, or null when it is that already.
+fn resizeOf(core: anytype, cols: u16, rows: u16, cell_w: u32, cell_h: u32, tag_w: u32, tag_h: u32) ?pardes.Event {
const metrics: pardes.RowMetrics = .{ .body_w = @intCast(cell_w), .body_h = @intCast(cell_h), .tagline_w = @intCast(tag_w), .tagline_h = @intCast(tag_h) };
const same_metrics = std.meta.eql(metrics, core.row_metrics);
if (comptime pardes.pdf_enabled) {
const cell_px_w: u16 = @intCast(@min(@max(1, cell_w), std.math.maxInt(u16)));
const cell_px_h: u16 = @intCast(@min(@max(1, cell_h), std.math.maxInt(u16)));
if (cols == core.screen_w and rows == core.screen_h and
- cell_px_w == core.cell_pixels.w and cell_px_h == core.cell_pixels.h and same_metrics) return false;
- core.update(.{ .resize = .{
+ cell_px_w == core.cell_pixels.w and cell_px_h == core.cell_pixels.h and same_metrics) return null;
+ return .{ .resize = .{
.cols = cols,
.rows = rows,
.cell_pixels = .{ .w = cell_px_w, .h = cell_px_h },
.row_metrics = metrics,
- } });
- } else {
- if (cols == core.screen_w and rows == core.screen_h and same_metrics) return false;
- core.update(.{ .resize = .{ .cols = cols, .rows = rows, .row_metrics = metrics } });
+ } };
}
- return true;
+ if (cols == core.screen_w and rows == core.screen_h and same_metrics) return null;
+ return .{ .resize = .{ .cols = cols, .rows = rows, .row_metrics = metrics } };
}
const TouchSample = struct { x: f32 = 0, y: f32 = 0, pressure: f32 = 1 };
@@ -1963,12 +1970,23 @@ fn setTransitionFields(
}
}
-pub const run = runNative;
+pub fn run(init: std.process.Init, opts: pardes.Options, headless: bool) !void {
+ return runNative(init, opts, headless, null);
+}
+
+/// `pardes-gui --attach=<socket>:<session>` (and `<host>:<session>`,
+/// through ssh, main.zig): this window a replica client of a session
+/// elsewhere, as the tty's `remote` is a terminal's (`remoteSession`).
+pub fn remote(init: std.process.Init, opts: pardes.Options, path: []const u8, session: []const u8, far: bool) !void {
+ return runNative(init, opts, false, .{ .path = path, .session = session, .far = far });
+}
+
+const Dial = struct { path: []const u8, session: []const u8, far: bool };
-fn runNative(init: std.process.Init, opts_in: pardes.Options, headless: bool) !void {
+fn runNative(init: std.process.Init, opts_in: pardes.Options, headless: bool, dial: ?Dial) !void {
const gpa = init.gpa;
const env = init.environ_map;
- if (env.get("PARDES_TEST_GRID") != null) return runGrid(init, opts_in);
+ if (dial == null and env.get("PARDES_TEST_GRID") != null) return runGrid(init, opts_in);
const test_mode = env.get("PARDES_TEST") != null;
const capture_dir = env.get("PARDES_TEST_CAPTURE_DIR");
@@ -2294,6 +2312,7 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, headless: bool) !v
// 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 (dial) |to| return remoteSession(init, &g, opts_in, test_mode, to);
try localSession(init, &g, opts_in, test_mode, headless);
}
@@ -2458,6 +2477,10 @@ fn localSession(
frame_capture_dir = if (std.c.getenv("PARDES_FRAMES_CAPTURE")) |dir| std.mem.span(dir) else null;
const host = shell.host();
core.host = host;
+ shell.peers = .{ .gpa = gpa, .io = io, .name = daemon.name(), .wake = sdlWake, .alone_unattended = headless };
+ defer shell.peers.deinit();
+ // Before the core goes: each client sees its link end.
+ defer shell.peers.dropAll(shell.core);
while (core.nextEffect()) |e| core.perform(e);
// An upgraded session's shells, once a fresh session's own has a
@@ -2496,20 +2519,25 @@ fn localSession(
if (headless) {
shell.closeTheWindow();
// Nothing else may wake the first wait.
- daemon.watch(&queue, deliverNote);
+ daemon.watch(&shell, deliverNote);
}
while (!core.quit) {
pardes.turn.bump(&pardes.turn.restores);
try core.pump(host);
+ // Its unit to each replica client, and theirs taken in.
+ shell.peers.boundary(core);
upgrade.locate();
// Asked in the step (the word), done between steps: the session whole.
if (shell.upgrade_asked) |pane| shell.upgradeNow(pane);
// A window asked for again, or an adopted shell, from the daemon's
// thread through the queue; started after the first frame.
- daemon.watch(&queue, deliverNote);
+ daemon.watch(&shell, deliverNote);
if (core.quit) break; // a session that ended does not restore into one
if (core.takeRestore()) |rp| blk: {
+ // ponytail: a Restore replaces the core its clients replicate;
+ // they are let go, and attach again (as the tty's).
+ shell.peers.dropAll(core);
const bytes = filesystem.readRestore(gpa, rp, core.settings.dump_dir.get()) catch |err| {
core.reportError(core.active, "Restore", err);
break :blk;
@@ -2525,6 +2553,7 @@ fn localSession(
// the others close.
shell.closeOtherWindows();
shell.gview = 0;
+ shell.windowed = 1;
shell.stopPtys();
for (0..pardes.MAX_PANES) |wid| file_watch.watchPane(
inotify_fd,
@@ -2561,6 +2590,314 @@ fn localSession(
}
}
+/// A window's link to a session elsewhere (`remoteSession`): what the
+/// window's input made, fed to the replica once its own view is put back,
+/// and what the link's reader took off the stream.
+const Client = struct {
+ link: replica.Link,
+ io: std.Io,
+ gpa: std.mem.Allocator,
+ /// The window's inputs since the last feed, their texts in `texts`:
+ /// read over its own view (`Replica.within`), applied after it.
+ pending: std.ArrayListUnmanaged(pardes.Event) = .empty,
+ texts: std.heap.ArenaAllocator,
+ /// The reader's, under `lock`: what it took, and whether the link ended.
+ lock: std.Io.Mutex = .init,
+ inbox: std.ArrayListUnmanaged(replica.Said) = .empty,
+ taken: std.ArrayListUnmanaged(replica.Said) = .empty,
+ ended: bool = false,
+
+ fn deinit(cl: *Client) void {
+ cl.pending.deinit(cl.gpa);
+ cl.texts.deinit();
+ cl.inbox.deinit(cl.gpa);
+ cl.taken.deinit(cl.gpa);
+ }
+
+ fn post(cl: *Client, ev: pardes.Event) void {
+ var e = ev;
+ const a = cl.texts.allocator();
+ switch (e) {
+ .key => |*k| k.text = a.dupe(u8, k.text) catch "",
+ .paste, .command => |*b| b.* = a.dupe(u8, b.*) catch return,
+ else => {},
+ }
+ cl.pending.append(cl.gpa, e) catch {};
+ }
+
+ /// What the window's input made, applied at once and sent.
+ fn feed(cl: *Client) void {
+ for (cl.pending.items) |ev| cl.link.input(ev);
+ cl.pending.clearRetainingCapacity();
+ _ = cl.texts.reset(.retain_capacity);
+ }
+
+ /// The reader's: a message of the stream, for the loop, which it wakes.
+ fn said(cl: *Client, msg: replica.Said) bool {
+ cl.lock.lockUncancelable(cl.io);
+ defer cl.lock.unlock(cl.io);
+ cl.inbox.append(cl.gpa, msg) catch return false;
+ sdlWake(null);
+ return true;
+ }
+
+ /// What the reader took, in its order, and the link's end after it.
+ fn takeSaid(cl: *Client) void {
+ cl.lock.lockUncancelable(cl.io);
+ std.mem.swap(std.ArrayListUnmanaged(replica.Said), &cl.inbox, &cl.taken);
+ const ended = cl.ended;
+ cl.lock.unlock(cl.io);
+ for (cl.taken.items) |msg| {
+ // PARDES_TEST_LATENCY: when a terminal's delta came (an echo's).
+ if (msg == .screen) latencyNote("S {d}\n", .{monoNs()});
+ cl.link.take(msg);
+ }
+ cl.taken.clearRetainingCapacity();
+ if (ended) {
+ cl.link.quit = true;
+ cl.link.gone = true;
+ }
+ }
+
+ /// Its own view drawn in the window, outside any step, as the tty's
+ /// client draws its terminal (tty.zig `Remote.draw`): what presenting
+ /// writes in the core (a frame skipped, one owed) is put back.
+ fn draw(cl: *Client, s: *Shell) void {
+ const r = cl.link.r;
+ const core = r.core();
+ const skipped = core.present_skipped;
+ const needs = core.needs_frame;
+ core.frames.mark_start = pardes.FrameStats.nowNs();
+ core.frames.mark_update = core.frames.mark_start;
+ r.draw(.{ .ctx = s, .f = present });
+ core.frames.mark_render = core.frames.mark_update;
+ cl.link.owed = core.present_skipped;
+ core.frames.record(pardes.FrameStats.nowNs(), false, cl.link.owed);
+ core.present_skipped = skipped;
+ core.needs_frame = needs;
+ cl.link.drawn(s.presented);
+ }
+};
+
+/// The session's stream, onto the client's inbox: its units, and its end.
+fn clientReader(cl: *Client, fd: c_int, rest: *replica.Framer) void {
+ replica.readLink(cl.gpa, fd, rest, cl, Client.said);
+ cl.lock.lockUncancelable(cl.io);
+ cl.ended = true;
+ cl.lock.unlock(cl.io);
+ sdlWake(null);
+}
+
+/// What the window does over its own view (`Replica.within`), its inputs
+/// posted to the client (`Input.remote`): an SDL event dispatched, its size
+/// (the tagline's face too), the pointer under a frame that moved, the
+/// timedemo's and the test feed's steps.
+const OwnView = struct {
+ g: *Gui,
+ in: *Input,
+ s: *Shell,
+ sev: ?*const c.SDL_Event = null,
+ pointer: bool = false,
+ eof: bool = false,
+
+ fn run(v: *OwnView, core: *pardes.Pardes) anyerror!void {
+ if (v.sev) |sev| return dispatch(v.g, v.in, sev);
+ const g = v.g;
+ if (fitTaglineFont(g, core.settings.font.tagline_percent)) v.s.remote.?.link.dirty = true;
+ const geom = windowCells(g);
+ if (resizeOf(core, geom.cols, geom.rows, g.cell_w, g.cell_h, g.tagline_width, g.tagline_height)) |ev| v.in.post(ev);
+ if (v.pointer) refreshPresentedPointer(g, v.in);
+ runDemo(g, v.in, core);
+ if (v.s.test_mode) {
+ const r = v.s.feed.pump(v.s.gpa, v.in, g) catch return error.TestFeed;
+ if (r.eof) v.eof = true;
+ }
+ }
+};
+
+/// `pardes-gui --attach=<where>:<session>`: the window, made as a session's
+/// is, a replica client of that session (docs/next-daemon.md, "Phase 6: GUI
+/// replica notes"). Its own core, loaded from the session's dump, applies
+/// its input at once (src/replica.zig) and draws its own view; the
+/// session's units are the truth it rolls back to. The tty's `remote`, with
+/// a window for a terminal.
+fn remoteSession(init: std.process.Init, g: *Gui, opts_in: pardes.Options, test_mode: bool, to: Dial) !void {
+ const io = init.io;
+ const gpa = init.gpa;
+ const Said = struct {
+ fn no(o: std.Io, comptime fmt: []const u8, args: anytype) noreturn {
+ var buf: [800]u8 = undefined;
+ std.Io.File.stderr().writeStreamingAll(o, std.fmt.bufPrint(&buf, "pardes-gui: --attach: " ++ fmt ++ "\n", args) catch "pardes-gui: --attach failed\n") catch {};
+ std.process.exit(1);
+ }
+ };
+ var why: [600]u8 = @splat(0);
+ // Far (through ssh, or PARDES_REPLICA_FAR=1): its join's blobs by hash
+ // and its stream in zstd, as the tty's client (replica.zig `Have`).
+ const far = if (init.environ_map.get("PARDES_REPLICA_FAR")) |v| std.mem.eql(u8, v, "1") else to.far;
+ var have_store: replica.Have = if (far) .init(io) else .{ .io = io };
+ defer have_store.deinit();
+ const have: ?*replica.Have = if (far) &have_store else null;
+ var dial_t0 = std.Io.Clock.awake.now(io).nanoseconds;
+ var joined = replica.dial(gpa, to.path, to.session, &why, have) orelse Said.no(io, "{s}", .{std.mem.sliceTo(&why, 0)});
+ if (joined.semantics != wire.semantics) Said.no(io, "{s}", .{replica.Link.upgrade_words});
+
+ const allocs = pardes.memory.init(gpa);
+ defer pardes.memory.deinit();
+ pardes.image.start(io, allocs.image);
+ if (comptime pardes.pdf_enabled) pardes.pdf.start(allocs.pdf);
+ pardes.syntax.start(allocs.tree_sitter);
+ defer {
+ pardes.image.stop();
+ if (comptime pardes.pdf_enabled) pardes.pdf.stop();
+ pardes.syntax.stop();
+ }
+ var o = opts_in;
+ o.image_allocator = allocs.image;
+ o.pdf_allocator = allocs.pdf;
+ var r = replica.Link.load(gpa, &joined, o, &why, have) orelse Said.no(io, "{s}", .{std.mem.sliceTo(&why, 0)});
+ var dial_ms: u64 = @intCast(@divTrunc(std.Io.Clock.awake.now(io).nanoseconds - dial_t0, std.time.ns_per_ms));
+
+ var client: Client = .{ .link = .{ .r = r, .fd = joined.fd }, .io = io, .gpa = gpa, .texts = .init(gpa) };
+ defer client.deinit();
+ const link = &client.link;
+ try link.fromEnv(gpa, init.environ_map);
+ defer link.deinit(gpa);
+ // A client spawns, watches and serves nothing: the Shell's tables are
+ // empty ones, there for what draws.
+ var ptys: [pardes.MAX_PANES]?Pty = @splat(null);
+ var gens: [pardes.MAX_PANES]u32 = @splat(0);
+ var queue: Queue = .{ .io = io, .gpa = gpa, .lsp_allocator = allocs.lsp };
+ defer queue.deinit();
+ var pipe_tasks: PipeTasks = .{};
+ var watches: file_watch.Table = @splat(null);
+ const prompt_rcs: host_io.Shell.PromptFiles = .{};
+ var shell: Shell = .{
+ .core = r.core(),
+ .gui = g,
+ .io = io,
+ .gpa = gpa,
+ .lsp_allocator = allocs.lsp,
+ .prompt_rcs = &prompt_rcs,
+ .ptys = &ptys,
+ .gens = &gens,
+ .queue = &queue,
+ .pipe_tasks = &pipe_tasks,
+ .inotify_fd = -1,
+ .watches = &watches,
+ .test_mode = test_mode,
+ .remote = &client,
+ };
+ defer shell.shaders.deinit(gpa, -1, &watches);
+ g.no_blink = test_mode;
+ defer g.hit_core = null;
+ _ = c.SDL_StartTextInput(g.window);
+ if (test_mode) setStdinRaw() catch {};
+ // A join a pass: the first, and one after the replica diverged or the
+ // session let it go to upgrade. The window stays as it is.
+ while (true) {
+ r.gmtoff = joined.gmtoff;
+ const core = r.core();
+ shell.core = core;
+ shell.gview = joined.view;
+ shell.surface = null;
+ g.hit_core = core;
+ frame_probe = &core.frames;
+ link.reset(r, joined.fd);
+ link.joinedAs(&joined, dial_ms);
+ client.ended = false;
+ // ponytail: why it joined again is the window's title (and its
+ // log) until a key, where a terminal's client draws it over its
+ // frame: a window's frame is the core's cells, which it cannot write.
+ var titled = link.notice_len > 0;
+ if (titled) {
+ var title: [260]u8 = undefined;
+ _ = c.SDL_SetWindowTitle(g.window, std.fmt.bufPrintSentinel(&title, "pardes: {s}", .{link.notice()}, 0) catch "pardes");
+ log.warn("{s}", .{link.notice()});
+ }
+ const reader = try std.Thread.spawn(.{}, clientReader, .{ &client, joined.fd, &joined.rest });
+ var in: Input = .{ .core = core, .shell = &shell, .remote = &client };
+ // What it is, then its size, are its view's first inputs.
+ link.input(.{ .frontend = .{ .windowed = true, .native_images = true, .native_image_patches = true } });
+ var drew = false;
+ while (!link.quit) {
+ core.frames.period_ns = refreshNs(g);
+ syncLigatures(g, core);
+ {
+ var passes: [Post.max]ShaderBuild.Pass = undefined;
+ g.post.sync(gpa, g.device, g.swapchain_format, shell.shaders.view(&core.settings.post, &passes), shell.shaders.revision, core);
+ }
+ var own: OwnView = .{ .g = g, .in = &in, .s = &shell, .pointer = drew };
+ r.within(&own, OwnView.run);
+ client.feed();
+ if (own.eof) break;
+ // Its predicted echo judged and caught up, once a frame.
+ if (r.echoFrame()) link.dirty = true;
+ drew = false;
+ if (link.dirty) {
+ client.draw(&shell);
+ drew = shell.presented;
+ }
+ const predicting = r.echo.n > 0 or r.echo.cursor != null or r.echo.nd > 0;
+ var ms: c_int = if (test_mode) 16 else -1;
+ if (demoDue(g)) |due| ms = if (ms < 0) due else @min(ms, due);
+ if (predicting or link.owed) ms = if (ms < 0) frame_ms else @min(ms, frame_ms);
+ if (link.quietCheck()) |wait| ms = if (ms < 0) @intCast(wait) else @min(ms, @as(c_int, @intCast(wait)));
+ // Idle, its frame drawn: the next input needs no copy taken.
+ if (ms != 0) r.ready();
+ var sev = std.mem.zeroes(c.SDL_Event);
+ g.input_seen = false;
+ var got = c.SDL_WaitEventTimeout(&sev, ms);
+ while (got) : (got = c.SDL_PollEvent(&sev)) {
+ if (sev.type == c.SDL_EVENT_USER) continue;
+ var one: OwnView = .{ .g = g, .in = &in, .s = &shell, .sev = &sev };
+ r.within(&one, OwnView.run);
+ client.feed();
+ if (link.quit) break;
+ }
+ client.takeSaid();
+ r.settle();
+ if (titled and link.notice_len == 0) {
+ titled = false;
+ _ = c.SDL_SetWindowTitle(g.window, "pardes");
+ }
+ if (link.owed or r.echo.changed) link.dirty = true;
+ if (r.diverged != null) link.quit = true;
+ }
+ if (init.environ_map.get("PARDES_REPLICA_STATS")) |file| link.writeStats(file);
+ if (!link.gone) replica.bye(joined.fd);
+ // The reader ends with the link: what it took meanwhile is let go.
+ _ = libc.shutdown(joined.fd, 2);
+ reader.join();
+ client.lock.lockUncancelable(io);
+ for (client.inbox.items) |msg| switch (msg) {
+ .unit, .screen, .refused => |b| std.heap.c_allocator.free(b),
+ .checked => {},
+ };
+ client.inbox.clearRetainingCapacity();
+ client.lock.unlock(io);
+ _ = libc.close(joined.fd);
+ joined.rest.deinit(gpa);
+ if (!link.rejoins()) {
+ // What it made since it joined, kept for its next start.
+ if (have) |h| h.keep(r.core());
+ r.deinit();
+ if (link.gone) Said.no(io, "'{s}' let this client go (a Detach in it, or the session's end)", .{to.session});
+ return;
+ }
+ // The session again, the core it leaves held meanwhile.
+ if (have) |h| h.leaving(r.core());
+ dial_t0 = std.Io.Clock.awake.now(io).nanoseconds;
+ joined = replica.Link.redial(gpa, to.path, to.session, &why, have) orelse Said.no(io, "{s}", .{std.mem.sliceTo(&why, 0)});
+ if (have) |h| h.left();
+ r.deinit();
+ r = replica.Link.load(gpa, &joined, o, &why, have) orelse Said.no(io, "{s}", .{std.mem.sliceTo(&why, 0)});
+ dial_ms = @intCast(@divTrunc(std.Io.Clock.awake.now(io).nanoseconds - dial_t0, std.time.ns_per_ms));
+ }
+}
+
+const frame_ms: c_int = @intCast(pardes.animation.frame_ns / std.time.ns_per_ms);
+
fn runGrid(init: std.process.Init, opts_in: pardes.Options) !void {
const io = init.io;
const gpa = init.gpa;
@@ -3090,14 +3427,33 @@ const Input = struct {
/// The shell whose windows these are: a window closed while others
/// stay takes its view with it (views.zig).
shell: ?*Shell = null,
+ /// A replica client's (`remote`): its inputs go to its link, never
+ /// straight to the core, which only reads here.
+ remote: ?*Client = null,
quit: bool = false,
fn post(in: *Input, ev: pardes.Event) void {
+ if (in.remote) |r| return r.post(ev);
+ // The window's input is its own view's, a replica client's input
+ // the session's last or not.
+ if (in.shell) |s| if (s.core.view != s.gview) {
+ _ = s.windowView();
+ };
if (in.core) |core| return core.update(ev);
}
fn close(in: *Input) void {
- if (in.shell) |s| if (pardes.views.count(s.core) > 1) return s.closeView(s.core.view);
+ if (in.remote) |r| {
+ r.link.quit = true;
+ in.quit = true;
+ return;
+ }
+ if (in.shell) |s| {
+ if (s.windowsOpen() > 1) return s.closeView(s.core.view);
+ // The last window, with replica clients: they keep the session,
+ // as a Detach would, the daemon holding it.
+ if (s.peers.count() > 0 and daemon.kept()) return s.closeTheWindow();
+ }
if (in.core) |core| core.quit = true;
in.quit = true;
}
@@ -3127,7 +3483,9 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
updateDisplayScale(g.window);
// Underlines are drawn into the glyphs a logical pixel thick.
resetGlyphAtlas(g);
- if (in.core) |core| core.needs_frame = true;
+ if (in.remote) |r| {
+ r.link.dirty = true;
+ } else 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),
@@ -3141,7 +3499,7 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
c.SDL_EVENT_WINDOW_CLOSE_REQUESTED => in.close(),
c.SDL_EVENT_WINDOW_FOCUS_GAINED => {
in.post(.{ .focus = true });
- if (in.core) |core| upgrade.noticeNewer(core);
+ if (in.remote == null) if (in.core) |core| upgrade.noticeNewer(core);
},
c.SDL_EVENT_WINDOW_FOCUS_LOST => in.post(.{ .focus = false }),
c.SDL_EVENT_WINDOW_MOUSE_LEAVE => {
@@ -3161,8 +3519,14 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
const want = std.math.clamp(g.px + step, font_px_min, font_px_max);
if (want != g.px) {
g.px = want;
- refitFont(g, in.core);
- if (in.core) |core| observeGuiFont(g, core);
+ // A client's view is sized by its next loop, as its input.
+ if (in.remote) |r| {
+ refitFont(g, null);
+ r.link.dirty = true;
+ } else {
+ refitFont(g, in.core);
+ if (in.core) |core| observeGuiFont(g, core);
+ }
}
return;
}
@@ -3590,6 +3954,18 @@ fn wheelAt(g: *Gui, in: *Input, w: WheelTurn, mc: MouseCell) void {
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 if (in.remote != null) {
+ // ponytail: a replica client's wheel moves the view a
+ // whole row a turn, with no glide and no touchpad's
+ // fraction: its core's clock is the session's, which
+ // moves only as its units come.
+ if (notchOf(w.y, w.integer_y)) |lines| {
+ g.program_wheel = @floatFromInt(lines);
+ } else 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, .shift = true } });
+ while (g.program_wheel <= -1) : (g.program_wheel += 1)
+ in.post(.{ .mouse = .{ .button = .wheel_up, .kind = .press, .col = mc.col, .row = mc.row, .shift = true } });
} else {
g.scroll_pane = id;
g.scroll_col = mc.col;
@@ -3680,10 +4056,11 @@ fn heldPointerButton(g: *const Gui) ?pardes.Mouse.Button {
return null;
}
-fn refreshPresentedPointer(g: *Gui, core: *pardes.Pardes) void {
+fn refreshPresentedPointer(g: *Gui, in: *Input) void {
if (!g.pointer_present) return;
+ const core = in.core orelse return;
const mc = mouseCell(g, core, g.pad_x, g.pad_y) orelse {
- if (g.pointer_mapped) core.update(.pointer_leave);
+ if (g.pointer_mapped) in.post(.pointer_leave);
g.pointer_mapped = false;
return;
};
@@ -3693,7 +4070,7 @@ fn refreshPresentedPointer(g: *Gui, core: *pardes.Pardes) void {
g.pointer_cell = mc;
if (!moved) return;
const held = heldPointerButton(g);
- core.update(.{ .mouse = .{
+ in.post(.{ .mouse = .{
.button = held orelse .none,
.kind = if (held != null) .drag else .motion,
.col = mc.col,
@@ -3806,6 +4183,22 @@ const Shell = struct {
gview: u8 = 0,
/// Upgrade was asked from this pane, to be done between steps (`upgradeNow`).
upgrade_asked: ?u8 = null,
+ /// This window a replica client of a session elsewhere (`remote`).
+ remote: ?*Client = null,
+ /// The session's replica clients (src/replica.zig), on sockets: views
+ /// of their own with no window here (`windowed`).
+ peers: replica.Peers = .{},
+ /// The views that are this process's windows (the rest are clients').
+ windowed: u8 = 1,
+ /// This wait took only a replica's post (its input, its join): the pump
+ /// after it reads no new time, so it moves nothing the replicas'
+ /// speculations stand on (tty.zig's `mail_only`).
+ mail_only: bool = false,
+ waited: bool = false,
+ /// With replica clients, a wait takes one person's input (tty.zig
+ /// `split`): the next is held for the next wait.
+ took_input: bool = false,
+ held: ?c.SDL_Event = null,
fn reap(s: *Shell) void {
const now = std.Io.Clock.awake.now(s.queue.io).toMilliseconds();
@@ -3894,9 +4287,11 @@ const Shell = struct {
/// window, for `pardes-gui --attach` to open one again.
fn detachWindow(ctx: ?*anyopaque) void {
const s = shellOf(ctx);
+ // A replica client's: its link ends.
+ if (s.peers.detach(s.core.view)) return;
if (s.gui == null) return s.core.reportFailure(s.core.active, "Detach: no window is open");
// One of several: its window goes, and the session stays in the rest.
- if (pardes.views.count(s.core) > 1) return s.closeView(s.core.view);
+ if (s.windowsOpen() > 1) return s.closeView(s.core.view);
if (!daemon.kept()) return s.core.reportFailure(s.core.active, "Detach: no pardes daemon keeps this session; closing its window ends it");
s.closeTheWindow();
}
@@ -3906,6 +4301,9 @@ const Shell = struct {
const g = s.gui orelse return;
const k = s.core.view;
if (s.gview == k) return;
+ // A replica client's view has no window here: the Gui keeps the one
+ // it holds (`windowView` puts that view back when it acts).
+ if (s.windowed & (@as(u8, 1) << @intCast(k)) == 0) return;
if (s.gview < s.windows.len) copyWindow(&s.windows[s.gview], g);
copyWindow(g, &s.windows[k]);
s.gview = k;
@@ -3916,7 +4314,11 @@ const Shell = struct {
if (!pardes.views.several(s.core)) return;
const g = s.gui orelse return;
const w = c.SDL_GetWindowFromEvent(sev) orelse return;
- if (w == g.window) return;
+ // The Gui's window's, while a client's view is live: its own again.
+ if (w == g.window) {
+ _ = s.windowView();
+ return;
+ }
for (s.windows, 0..) |win, k| if (k != s.gview and pardes.views.isOpen(s.core, @intCast(k)) and win.window == w) {
s.core.toView(@intCast(k));
return s.follow();
@@ -3950,10 +4352,20 @@ const Shell = struct {
if (g.capture_dir.len > 0) std.Io.Dir.cwd().createDirPath(s.io, g.capture_dir) catch {};
}
s.gview = k;
+ s.windowed |= @as(u8, 1) << @intCast(k);
s.core.toView(k);
s.core.needs_frame = true;
}
+ /// The Gui's window's view live, for what the window does to its own
+ /// (its size, its scroll): a replica client's input may have been the
+ /// last. True when it was not, and is now.
+ fn windowView(s: *Shell) bool {
+ if (s.core.view == s.gview or !pardes.views.isOpen(s.core, s.gview)) return false;
+ s.core.toView(s.gview);
+ return true;
+ }
+
/// View `k`'s window closed while others stay: the view goes with it.
fn closeView(s: *Shell, k: u8) void {
const g = s.gui orelse return;
@@ -3962,11 +4374,40 @@ const Shell = struct {
closeWindow(g);
releaseWindowParts(g, s.gpa);
s.gview = std.math.maxInt(u8);
+ s.windowed &= ~(@as(u8, 1) << @intCast(k));
s.core.closeView(k);
+ // Into another window's view, if a client's was the one left live.
+ for (0..pardes.views.max) |i| if (s.windowed & (@as(u8, 1) << @intCast(i)) != 0 and pardes.views.isOpen(s.core, @intCast(i))) {
+ if (s.core.view != i) s.core.toView(@intCast(i));
+ break;
+ };
s.follow();
s.core.needs_frame = true;
}
+ /// With replica clients, a wait takes one person's input and its pump
+ /// makes one unit of it (tty.zig `split`): whether `sev`, a second, is
+ /// held for the next wait. Any event but a wake is no replica's post.
+ fn split(s: *Shell, sev: *const c.SDL_Event) bool {
+ if (sev.type != c.SDL_EVENT_USER) s.mail_only = false;
+ if (!s.peers.recording) return false;
+ switch (sev.type) {
+ c.SDL_EVENT_KEY_DOWN, c.SDL_EVENT_TEXT_INPUT, c.SDL_EVENT_MOUSE_BUTTON_DOWN, c.SDL_EVENT_MOUSE_BUTTON_UP, c.SDL_EVENT_MOUSE_MOTION, c.SDL_EVENT_MOUSE_WHEEL, c.SDL_EVENT_WINDOW_FOCUS_GAINED, c.SDL_EVENT_WINDOW_FOCUS_LOST, c.SDL_EVENT_WINDOW_MOUSE_LEAVE, c.SDL_EVENT_FINGER_DOWN, c.SDL_EVENT_FINGER_MOTION, c.SDL_EVENT_FINGER_UP, c.SDL_EVENT_PINCH_BEGIN, c.SDL_EVENT_PINCH_UPDATE => {},
+ else => return false,
+ }
+ if (s.took_input) {
+ s.held = sev.*;
+ return true;
+ }
+ s.took_input = true;
+ return false;
+ }
+
+ /// How many of the session's views are windows here.
+ fn windowsOpen(s: *const Shell) usize {
+ return @popCount(s.windowed & s.core.views_open);
+ }
+
/// The session's end: every window but the live one closed.
fn closeOtherWindows(s: *Shell) void {
const g = s.gui orelse return;
@@ -3989,7 +4430,9 @@ const Shell = struct {
s.gui = null;
s.presented = false;
s.surface = null;
- s.core.unattended = true;
+ // Its clients look at it still (Peers keeps it attended).
+ s.peers.alone_unattended = true;
+ s.core.unattended = s.peers.count() == 0;
daemon.setState(true);
}
@@ -4001,6 +4444,7 @@ const Shell = struct {
}
s.gui = g;
s.parked = null;
+ s.peers.alone_unattended = false;
s.core.unattended = false;
s.core.needs_frame = true;
resetScroll(g);
@@ -4051,6 +4495,9 @@ const Shell = struct {
};
s.drainQueue();
core.settle();
+ // Its replica clients told, their views gone before the dump: each
+ // dials the session again once it is back.
+ s.peers.refuseAll(core, "the session is upgrading to another build of pardes");
var rec: upgrade.Record = .{ .link = daemon.link, .window = s.gui != null, .exe = path };
for (s.ptys, 0..) |slot, id| if (slot) |pt| if (pt.fd >= 0) rec.addPty(id, pt.pid, pt.fd);
var at_buf: [1024:0]u8 = undefined;
@@ -4100,6 +4547,7 @@ const Shell = struct {
for (0..pardes.views.max) |i| {
const k: u8 = @intCast(i);
if (k != live and pardes.views.isOpen(s.core, k)) s.openAnotherWindow(k);
+ s.windowed |= @as(u8, 1) << @intCast(live);
}
s.core.toView(live);
s.follow();
@@ -4200,6 +4648,7 @@ const Shell = struct {
defer s.takeExits();
s.queue.takeInto(&s.batch);
const msgs = &s.batch;
+ if (msgs.len > 0) s.mail_only = false;
var check_files = false;
for (msgs.slice()) |m| switch (m) {
.output => |o| {
@@ -4311,6 +4760,9 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
const core = s.core;
var in: Input = .{ .core = core, .shell = s };
s.follow();
+ s.mail_only = true;
+ s.took_input = false;
+ defer s.waited = true;
if (s.gui) |g| {
var sev = std.mem.zeroes(c.SDL_Event);
// Idle is asleep until an event: SDL's own, and the user events the
@@ -4372,9 +4824,13 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
ms = 0;
}
g.input_seen = false;
+ // An input held from the last wait (`split`) is this one's, at once.
+ const held = s.held;
+ s.held = null;
+ if (held) |h| sev = h;
// The wait is the 9P connections' turn with the core.
pardes.turn.rest();
- const got = c.SDL_WaitEventTimeout(&sev, ms);
+ const got = held != null or 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
@@ -4402,6 +4858,7 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
// each would repeat hover and selection work the next undoes.
var motion: ?c.SDL_Event = null;
while (true) {
+ if (s.split(&sev)) break;
if (sev.type == c.SDL_EVENT_MOUSE_MOTION and (motion == null or motion.?.motion.windowID == sev.motion.windowID)) {
motion = sev;
} else {
@@ -4440,17 +4897,20 @@ fn waitInput(ctx: ?*anyopaque, timeout_ms: u32) void {
// 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) {
+ while (paced and !g.input_seen and s.held == null) {
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) {
- s.route(&sev);
- dispatch(g, &in, &sev);
- while (c.SDL_PollEvent(&sev)) {
+ if (!s.split(&sev)) {
s.route(&sev);
dispatch(g, &in, &sev);
+ while (c.SDL_PollEvent(&sev)) {
+ if (s.split(&sev)) break;
+ s.route(&sev);
+ dispatch(g, &in, &sev);
+ }
}
} else {
// The events asked for every 100 µs, the core busy between.
@@ -4510,6 +4970,16 @@ fn pollFrame(ctx: ?*anyopaque) void {
}
return;
};
+ // A replica client's view live: the window's own view back before what
+ // the window does to it (its size, its scroll, its font).
+ if (core.view != s.gview) {
+ const geom = windowCells(g);
+ const own = if (core.parked[s.gview]) |slot| &slot.view else null;
+ const due = g.scroll_pane != null or g.scroll_notch != 0 or g.glide.moving() or
+ core.settings.font.tagline_percent != g.tagline_percent or core.settings.font.pending or
+ (own != null and resizeOf(own.?, geom.cols, geom.rows, g.cell_w, g.cell_h, g.tagline_width, g.tagline_height) != null);
+ if (due) _ = s.windowView();
+ }
syncWindowOpacity(g, core);
core.frames.period_ns = refreshNs(g);
syncTaglineFont(g, core);
@@ -4680,16 +5150,8 @@ fn refreshNs(g: *const Gui) u64 {
}
fn finishWindowOpacity(core: *pardes.Pardes, applied: *u8, failure: ?[]const u8) void {
- core.settings.window_opacity_pending = false;
- if (failure) |reason| {
- // Do not claim a value the compositor refused; an explicit retry of
- // the same command will arm a new request.
- core.settings.window_opacity = applied.*;
- var buf: [256]u8 = undefined;
- core.setMessage(core.active, std.fmt.bufPrint(&buf, "WindowOpacity: {s}", .{reason[0..@min(reason.len, 240)]}) catch "WindowOpacity: compositor rejected the request");
- } else {
- applied.* = core.settings.window_opacity;
- }
+ core.windowOpacityDone(applied.*, failure);
+ applied.* = core.settings.window_opacity;
}
fn syncWindowOpacity(g: *Gui, core: *pardes.Pardes) void {
@@ -4758,7 +5220,9 @@ fn present(ctx: ?*anyopaque, surface: *const pardes.Surface) void {
g.scene_failures +|= 1;
log.err("scene target unavailable (attempt {d}/3)", .{g.scene_failures});
if (g.scene_failures >= 3) {
- core.disableSceneEffects();
+ // ponytail: a client's window keeps asking (its core is the
+ // session's to change).
+ if (s.remote == null) core.disableSceneEffects();
g.scene_failures = 0;
}
} else if (scene_requested and s.presented) g.scene_failures = 0;
@@ -4772,12 +5236,20 @@ fn postPresent(ctx: ?*anyopaque) void {
// the pump advances it all the same.
if (!s.presented) return;
const frame = s.surface orelse return;
- refreshPresentedPointer(g, s.core);
+ // A client's view live: the window's frame is acknowledged when its
+ // own view is live and drawn.
+ if (s.core.view != s.gview) return;
+ var in: Input = .{ .core = s.core };
+ refreshPresentedPointer(g, &in);
s.core.acknowledgePanelPresentation(frame.panelTracks());
}
fn guiNow(ctx: ?*anyopaque) u64 {
const s = shellOf(ctx);
+ if (s.waited) {
+ s.waited = false;
+ if (s.mail_only and s.peers.count() > 0 and s.core.clock_started) return s.core.now_ns;
+ }
return s.test_clock orelse s.paced_ns orelse c.SDL_GetTicksNS();
}
@@ -4871,7 +5343,8 @@ fn takeShell(s: *Shell, pane: u8, a: Adoption) void {
/// The daemon's thread: what it says, onto the queue (drainQueue).
fn deliverNote(ctx: *anyopaque, note: daemon.Note) void {
- const q: *Queue = @ptrCast(@alignCast(ctx));
+ const s: *Shell = @ptrCast(@alignCast(ctx));
+ const q = s.queue;
switch (note) {
.attach => |a| {
// A terminal for a window session: the daemon refuses that kind
@@ -4884,9 +5357,8 @@ fn deliverNote(ctx: *anyopaque, note: daemon.Note) void {
for (a.pids[0..a.n], a.fds[0..a.n]) |pid, fd| q.push(.{ .adopted = .{ .pid = pid, .fd = fd } });
q.push(.{ .adopted = .{ .pid = 0, .fd = -1 } });
},
- // ponytail: a window session serves no replica yet; a terminal's
- // does (tty.zig).
- .replica => |fd| daemon.refuseReplica(fd, "a window session takes no replica yet: run the session in a terminal, or --detach"),
+ // Joined at the next step boundary (Peers, any thread).
+ .replica => |fd| s.peers.handed(fd),
}
}
@@ -7974,8 +8446,14 @@ fn syncLigatures(g: *Gui, core: *pardes.Pardes) void {
}
fn syncTaglineFont(g: *Gui, core: *pardes.Pardes) void {
- const percent = core.settings.font.tagline_percent;
- if (percent == g.tagline_percent) return;
+ if (!fitTaglineFont(g, core.settings.font.tagline_percent)) return;
+ const geom = windowCells(g);
+ _ = updateCoreResize(core, geom.cols, geom.rows, g.cell_w, g.cell_h, g.tagline_width, g.tagline_height);
+}
+
+/// The tagline's face at `percent` of the body's: whether it changed.
+fn fitTaglineFont(g: *Gui, percent: u8) bool {
+ if (percent == g.tagline_percent) return false;
g.tagline_percent = percent;
const tagline = taglineRaster(g.font, g.px, g.cell_w, g.cell_h, percent);
g.tagline_px = tagline.px;
@@ -7983,8 +8461,7 @@ fn syncTaglineFont(g: *Gui, core: *pardes.Pardes) void {
g.tagline_baseline = tagline.baseline;
g.tagline_height = tagline.height;
resetGlyphAtlas(g);
- const geom = windowCells(g);
- _ = updateCoreResize(core, geom.cols, geom.rows, g.cell_w, g.cell_h, g.tagline_width, g.tagline_height);
+ return true;
}
/// What text draws, so a frame does not work it out again. `cells` is the