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.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