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.zig374
1 files changed, 325 insertions, 49 deletions
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index d3acf454..c12041c0 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -15,6 +15,7 @@ const file_watch = @import("../file_watch.zig");
const ShaderBuild = @import("../ShaderBuild.zig");
const deck = @import("deck.zig");
const Post = @import("Post.zig");
+const Trackpad = @import("Trackpad.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");
@@ -886,7 +887,6 @@ const Pty = struct {
cmd: host_io.CommandWatch = .{},
};
-
const RetiredShell = struct { pid: libc.pid_t = 0, kill_at: i64 = 0 };
const Queue = host_io.Inbox;
@@ -1283,8 +1283,6 @@ test "GUI completion reset frees queued payloads and rejects late LSP workers" {
try std.testing.expectEqual(@as(usize, 0), queue.take().len);
}
-
-
fn stopPipe() ![2]c_int {
var fds: [2]c_int = undefined;
if (libc.pipe(&fds) != 0) return error.PipeFailed;
@@ -1295,7 +1293,6 @@ fn stopPipe() ![2]c_int {
return fds;
}
-
fn watchThread(fd: c_int, stop: c_int, q: *Queue) void {
while (true) {
var fds = [_]libc.pollfd{
@@ -1312,8 +1309,6 @@ fn watchThread(fd: c_int, stop: c_int, q: *Queue) void {
}
}
-
-
test "GUI LSP query answers, and a newer one cancels it" {
const gpa = std.testing.allocator;
const io = std.testing.io;
@@ -1338,7 +1333,6 @@ test "GUI LSP query answers, and a newer one cancels it" {
try std.testing.expect(core.lsp_wait == null);
}
-
test "GUI worker setup failures finish matching LSP and pipe requests" {
const gpa = std.testing.allocator;
var failing_vtable = std.testing.io.vtable.*;
@@ -1436,6 +1430,8 @@ const Gui = struct {
font_bytes: []u8 = &.{},
font_name: [255]u8 = @splat(0),
font_name_len: u8 = 0,
+ remote_font_request: ?u64 = null,
+ trackpad: Trackpad = .{},
fallbacks: [max_fallback_fonts]?LoadedFallback = @splat(null),
fallback_count: usize = 0,
px: f32,
@@ -1481,6 +1477,7 @@ const Gui = struct {
/// A touchpad's fraction toward the next turn sent to a program that
/// owns the wheel (terminal.ownsWheel).
program_wheel: f32 = 0,
+ program_wheel_x: f32 = 0,
glide: Glide = .{},
/// PARDES_FRAMES_DEMO: the timedemo (FrameStats.named), its next step
/// and when it started; null when none runs.
@@ -1565,16 +1562,17 @@ const Gui = struct {
/// device, the atlas, the font and the pipelines are every window's. The
/// Gui holds the live window's; the others wait in `Shell.windows`.
const window_fields = [_][:0]const u8{
- "window", "soft_renderer", "soft_texture", "soft_tex_w", "soft_tex_h",
- "window_w", "window_h", "scroll_pane", "scroll_rect", "scroll_body_y",
- "scroll_body_h", "scroll_held_px", "scroll_col", "scroll_row", "scroll_delta",
- "scroll_lag", "scroll_edge", "scroll_edge_len", "scroll_notch", "program_wheel",
- "glide", "pace_ns", "sel_glow", "hover_glow", "frame_arrival_ns",
- "blink_due", "cursor_quad_alpha", "scene_tex", "scene_tex_w", "scene_tex_h",
- "scene_failures", "scene_target_failed", "post", "pointer_present", "pointer_shape",
- "pointer_mapped", "pointer_cell", "presented_images", "prepared_images", "touch",
- "live_ctrl", "live_alt", "applied_window_opacity", "capture_tex", "capture_tex_w",
- "capture_tex_h", "capture_xfer", "capture_xfer_size", "captured", "capture_dir",
+ "window", "soft_renderer", "soft_texture", "soft_tex_w", "soft_tex_h",
+ "window_w", "window_h", "scroll_pane", "scroll_rect", "scroll_body_y",
+ "scroll_body_h", "scroll_held_px", "scroll_col", "scroll_row", "scroll_delta",
+ "scroll_lag", "scroll_edge", "scroll_edge_len", "scroll_notch", "program_wheel",
+ "program_wheel_x", "glide", "pace_ns", "sel_glow", "hover_glow",
+ "frame_arrival_ns", "blink_due", "cursor_quad_alpha", "scene_tex", "scene_tex_w",
+ "scene_tex_h", "scene_failures", "scene_target_failed", "post", "pointer_present",
+ "pointer_shape", "pointer_mapped", "pointer_cell", "presented_images", "prepared_images",
+ "touch", "trackpad", "live_ctrl", "live_alt", "applied_window_opacity",
+ "capture_tex", "capture_tex_w", "capture_tex_h", "capture_xfer", "capture_xfer_size",
+ "captured", "capture_dir",
};
const GuiWindow = blk: {
@@ -1642,6 +1640,43 @@ fn acknowledgeGuiFont(g: *const Gui, core: *pardes.Pardes) void {
_ = core.acknowledgeFont(guiFontName(g), size, .pixels);
}
+/// A replica's font is local raster state. It follows the remote request
+/// without acknowledging or otherwise changing the replicated core.
+fn syncReplicaFont(g: *Gui, core: *const pardes.Pardes, gpa: std.mem.Allocator) bool {
+ const f = &core.settings.font;
+ const path = f.requested_path.get();
+ const name = f.requested_name.get();
+ if (path.len == 0 and name.len == 0) return false;
+ var hash = std.hash.Wyhash.init(0);
+ hash.update(path);
+ hash.update(name);
+ hash.update(std.mem.asBytes(&f.requested_size_hundredths));
+ const request = hash.final();
+ if (g.remote_font_request == request) return false;
+ g.remote_font_request = request;
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ const face = fonts.remote(arena.allocator(), path, name) orelse {
+ log.warn("remote font is not installed locally: {s}", .{name});
+ return false;
+ };
+ const bytes = filesystem.readFile(gpa, face.path) catch return false;
+ const font = c.ui_font_new(bytes.ptr, @intCast(bytes.len)) orelse {
+ gpa.free(bytes);
+ return false;
+ };
+ c.ui_font_free(g.font);
+ if (g.font_bytes.len != 0) gpa.free(g.font_bytes);
+ g.font = font;
+ g.font_bytes = bytes;
+ if (f.requested_size_hundredths != 0)
+ g.px = @as(f32, @floatFromInt(f.requested_size_hundredths)) / 100;
+ setGuiFontName(g, face.name);
+ refitFont(g, null);
+ log.info("remote font: {s} from {s}, {d} pixels", .{ guiFontName(g), face.path, g.px });
+ return true;
+}
+
fn loadFallbackFonts(g: *Gui, gpa: std.mem.Allocator) void {
if (c.ui_font_new(font_ttf.ptr, @intCast(font_ttf.len))) |face| {
g.fallbacks[0] = .{ .face = face };
@@ -2010,6 +2045,7 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, headless: bool, di
}
_ = c.SDL_SetHint("SDL_JOYSTICK_HIDAPI", "1"); // SDL_HINT_JOYSTICK_HIDAPI
_ = c.SDL_SetHint("SDL_JOYSTICK_HIDAPI_STEAMDECK", "1"); // ..._STEAMDECK
+ if (comptime builtin.os.tag == .macos) _ = c.SDL_SetHint(c.SDL_HINT_MAC_SCROLL_MOMENTUM, "1");
if (!c.SDL_Init(c.SDL_INIT_VIDEO | c.SDL_INIT_GAMEPAD)) {
log.err("SDL_Init: {s}", .{c.SDL_GetError()});
return error.SdlInit;
@@ -2055,6 +2091,7 @@ fn runNative(init: std.process.Init, opts_in: pardes.Options, headless: bool, di
return error.SdlInit;
};
var window_slot: ?*c.SDL_Window = window;
+ if (comptime builtin.os.tag == .macos) c.ui_macos_trackpad_attach(window);
defer if (window_slot) |open| c.SDL_DestroyWindow(open);
if (want_at) |at| _ = c.SDL_SetWindowPosition(window, at[0], at[1]);
updateDisplayScale(window);
@@ -2339,6 +2376,7 @@ fn closeWindow(g: *Gui) void {
/// size the last one had. False when the display will not give one.
fn reopenWindow(g: *Gui) bool {
const window = c.SDL_CreateWindow("pardes", g.window_w, g.window_h, g.win_flags) orelse return false;
+ if (comptime builtin.os.tag == .macos) c.ui_macos_trackpad_attach(window);
if (g.soft_present) {
g.soft_renderer = c.SDL_CreateRenderer(window, null) orelse {
c.SDL_DestroyWindow(window);
@@ -2685,7 +2723,7 @@ const Client = struct {
core.frames.mark_render = core.frames.mark_update;
r.draw(.{ .ctx = s, .f = present });
cl.link.owed = core.present_skipped;
- core.frames.record(pardes.FrameStats.nowNs(), false, cl.link.owed);
+ core.frames.record(pardes.FrameStats.nowNs(), r.animating(), cl.link.owed);
core.present_skipped = skipped;
core.needs_frame = needs;
cl.link.drawn(s.presented);
@@ -2716,6 +2754,8 @@ const OwnView = struct {
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 (syncReplicaFont(g, core, v.s.gpa)) v.s.remote.?.link.dirty = true;
+ if (stepRemoteScroll(g, v.in, v.s.gpa)) v.s.remote.?.link.dirty = true;
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);
@@ -2810,6 +2850,7 @@ fn remoteSession(init: std.process.Init, g: *Gui, opts_in: pardes.Options, test_
// session let it go to upgrade. The window stays as it is.
while (true) {
r.gmtoff = joined.gmtoff;
+ g.remote_font_request = null;
const core = r.core();
shell.core = core;
shell.gview = joined.view;
@@ -2851,16 +2892,33 @@ fn remoteSession(init: std.process.Init, g: *Gui, opts_in: pardes.Options, test_
client.draw(&shell);
drew = shell.presented;
}
+ // Render-time motion belongs to this window. No daemon unit
+ // need arrive while a cursor lands or a focus glow fades.
+ const moving = r.animating() or g.sel_glow.fading or g.hover_glow.fading or g.post.animating(core.settings.shader_animation);
+ const minimized = !test_mode and c.SDL_GetWindowFlags(g.window) & (c.SDL_WINDOW_MINIMIZED | c.SDL_WINDOW_OCCLUDED) != 0;
+ const blink = if (minimized) null else blinkNow(g, if (shell.surface) |frame| &frame.chrome else null);
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 (moving and !minimized) {
+ const frame_wait: c_int = @intCast(@max(1, (refreshNs(g) + std.time.ns_per_ms - 1) / std.time.ns_per_ms));
+ ms = if (ms < 0) frame_wait else @min(ms, frame_wait);
+ }
+ if (blink) |b| {
+ const due: ?u64 = if (b.edge) refreshNs(g) else b.next_ns;
+ if (due) |ns| {
+ const wait: c_int = @intCast(@min(std.math.maxInt(c_int), ns / std.time.ns_per_ms + 1));
+ ms = if (ms < 0) wait else @min(ms, wait);
+ }
+ }
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);
+ const timed_out = !got;
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 };
@@ -2875,6 +2933,7 @@ fn remoteSession(init: std.process.Init, g: *Gui, opts_in: pardes.Options, test_
_ = c.SDL_SetWindowTitle(g.window, "pardes");
}
if (link.owed or r.echo.changed) link.dirty = true;
+ if (!minimized and (moving or (blink != null and (blink.?.edge or timed_out)))) link.dirty = true;
if (r.diverged != null) link.quit = true;
}
if (init.environ_map.get("PARDES_REPLICA_STATS")) |file| link.writeStats(file);
@@ -3473,6 +3532,12 @@ const Input = struct {
};
fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
+ if (comptime builtin.os.tag == .macos) {
+ if (sev.type == c.ui_macos_trackpad_event_type()) {
+ dispatchTrackpad(g, in, @ptrCast(@alignCast(sev)));
+ return;
+ }
+ }
// 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) {
@@ -3564,7 +3629,11 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
},
c.SDL_EVENT_MOUSE_BUTTON_DOWN, c.SDL_EVENT_MOUSE_BUTTON_UP => {
const b = sev.button;
- const button: pardes.Mouse.Button = switch (b.button) {
+ const raw_button = if (comptime builtin.os.tag == .macos)
+ (if (b.down) g.trackpad.press(b.button) else g.trackpad.release(b.button) orelse return)
+ else
+ b.button;
+ const button: pardes.Mouse.Button = switch (raw_button) {
1 => .left,
2 => .middle,
3 => .right,
@@ -3602,7 +3671,7 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
g.pad_x = m.x;
g.pad_y = m.y;
g.pointer_present = true;
- const held: ?pardes.Mouse.Button = if ((m.state & c.SDL_BUTTON_LMASK) != 0)
+ const physical_held: ?pardes.Mouse.Button = if ((m.state & c.SDL_BUTTON_LMASK) != 0)
.left
else if ((m.state & c.SDL_BUTTON_MMASK) != 0)
.middle
@@ -3610,6 +3679,15 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
.right
else
null;
+ const held: ?pardes.Mouse.Button = if (comptime builtin.os.tag == .macos)
+ (if (g.trackpad.forced) null else if (g.trackpad.button) |b| switch (b) {
+ 1 => .left,
+ 2 => .middle,
+ 3 => .right,
+ else => physical_held,
+ } else physical_held)
+ else
+ physical_held;
const mc = mouseCell(g, in.core, m.x, m.y) orelse {
g.pointer_mapped = false;
in.post(.pointer_leave);
@@ -3636,6 +3714,9 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
},
c.SDL_EVENT_FINGER_DOWN, c.SDL_EVENT_FINGER_MOTION, c.SDL_EVENT_FINGER_UP, c.SDL_EVENT_FINGER_CANCELED => {
const f = sev.tfinger;
+ // Indirect Mac touches are decoded by AppKit at the pointer,
+ // never as absolute positions across the window.
+ if (comptime builtin.os.tag == .macos) if (f.touchID == c.SDL_MOUSE_TOUCHID) return;
const finger: Finger = .{
.kind = switch (sev.type) {
c.SDL_EVENT_FINGER_DOWN => .down,
@@ -3657,7 +3738,7 @@ fn dispatch(g: *Gui, in: *Input, sev: *const c.SDL_Event) void {
const fch: f32 = @floatFromInt(g.cell_h);
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_PINCH_BEGIN, c.SDL_EVENT_PINCH_UPDATE => zoomTrackpad(g, in, sev.pinch.scale),
c.SDL_EVENT_GAMEPAD_ADDED => {
if (g.gamepad == null) g.gamepad = c.SDL_OpenGamepad(sev.gdevice.which);
},
@@ -3968,13 +4049,16 @@ fn wheelAt(g: *Gui, in: *Input, w: WheelTurn, mc: MouseCell) void {
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);
+ } else {
+ // Fractions are local raster state; whole rows are
+ // ordinary inputs, confirmed by the authority.
+ g.scroll_pane = id;
+ g.scroll_col = mc.col;
+ g.scroll_row = mc.row;
+ g.scroll_delta = accumulateWheelDelta(g.scroll_delta, 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)
@@ -3999,20 +4083,118 @@ fn wheelAt(g: *Gui, in: *Input, w: WheelTurn, mc: MouseCell) void {
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,
- } });
+ var horizontal: i32 = if (w.x == 0 or !std.math.isFinite(w.x)) 0 else if (w.x > 0) 1 else -1;
+ if (w.precise and std.math.isFinite(w.x)) {
+ g.program_wheel_x += std.math.clamp(w.x, -64, 64);
+ horizontal = @intFromFloat(@trunc(g.program_wheel_x));
+ g.program_wheel_x -= @floatFromInt(horizontal);
+ }
+ while (horizontal != 0) {
+ in.post(.{ .mouse = .{
+ .button = if (horizontal > 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,
+ } });
+ horizontal += if (horizontal > 0) -1 else 1;
+ }
+}
+
+const WheelTurn = struct { x: f32 = 0, y: f32 = 0, integer_y: i32 = 0, precise: bool = false, mods: PointerMods = .{} };
+
+fn zoomTrackpad(g: *Gui, in: *Input, scale: f32) void {
+ const want = Trackpad.pinch(g.px, scale);
+ if (want == g.px) return;
+ g.px = want;
+ if (in.remote) |client| {
+ refitFont(g, null);
+ client.link.dirty = true;
+ } else {
+ refitFont(g, in.core);
+ if (in.core) |core| observeGuiFont(g, core);
+ }
}
-const WheelTurn = struct { x: f32 = 0, y: f32 = 0, integer_y: i32 = 0, mods: PointerMods = .{} };
+fn dispatchTrackpad(g: *Gui, in: *Input, ev: *const c.UITrackpadEvent) void {
+ g.input_seen = true;
+ switch (ev.kind) {
+ c.UI_TRACKPAD_FINGERS => g.trackpad.countFingers(@intCast(@max(ev.fingers, 0))),
+ c.UI_TRACKPAD_PINCH => if (g.trackpad.magnify(g.px, ev.a, ev.phase)) |want| zoomTrackpad(g, in, want / g.px),
+ c.UI_TRACKPAD_HISTORY => {
+ if (ev.a == 0 or !std.math.isFinite(ev.a)) return;
+ const back = ev.a < 0;
+ const can_jump = if (in.core) |core| core.njumps > 0 and
+ (if (back) core.jcur > 0 else core.jcur + 1 < core.njumps) else false;
+ in.post(.{ .command = if (back) "Back" else "Forward" });
+ if (comptime builtin.os.tag == .macos) if (can_jump) c.ui_macos_trackpad_haptic();
+ },
+ c.UI_TRACKPAD_ROTATE => {
+ if (in.core) |core| {
+ const pane = core.panes[core.active] orelse return;
+ // Search-step keys never become text in insert/raw mode.
+ if (pane.body.mode != .normal) return;
+ }
+ var ticks = g.trackpad.rotate(ev.a, ev.phase);
+ while (ticks != 0) {
+ in.post(.{ .key = .{ .cp = if (ticks > 0) 'N' else 'n' } });
+ if (comptime builtin.os.tag == .macos) c.ui_macos_trackpad_haptic();
+ ticks += if (ticks > 0) -1 else 1;
+ }
+ },
+ c.UI_TRACKPAD_PRESSURE => {
+ const previous = g.trackpad.force(ev.a) orelse return;
+ const mc = mouseCell(g, in.core, ev.x, ev.y) orelse g.pointer_cell orelse return;
+ in.post(.{ .mouse = pointerMouse(if (previous == 2) .middle else .left, .release, mc, pointerMods()) });
+ in.post(.{ .mouse = pointerMouse(.right, .press, mc, pointerMods()) });
+ in.post(.{ .mouse = pointerMouse(.right, .release, mc, pointerMods()) });
+ },
+ c.UI_TRACKPAD_SCROLL => {
+ const mc = mouseCell(g, in.core, ev.x, ev.y) orelse return;
+ g.pointer_present = true;
+ g.pointer_mapped = true;
+ g.pointer_cell = mc;
+ // AppKit reports points; the grid is measured in backing pixels.
+ const geometry = windowGeometry(g.window);
+ const rows = ev.b * geometry.pixel_h / geometry.window_h / @as(f32, @floatFromInt(g.cell_h));
+ const cols = -ev.a * geometry.pixel_w / geometry.window_w / @as(f32, @floatFromInt(g.cell_w));
+ wheelAt(g, in, .{ .x = cols, .y = rows, .precise = true, .mods = pointerMods() }, mc);
+ },
+ else => {},
+ }
+}
+
+test "trackpad rotation never types search keys into an insert-mode file or raw terminal" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 60, .rows = 16 });
+ defer core.deinit();
+ _ = try core.setTestFile("unchanged\n");
+ var client: Client = .{ .link = undefined, .io = std.testing.io, .gpa = gpa, .texts = .init(gpa) };
+ defer client.deinit();
+ var in: Input = .{ .core = core, .remote = &client };
+ var g: Gui = undefined;
+ g.trackpad = .{};
+ var ev: c.UITrackpadEvent = std.mem.zeroes(c.UITrackpadEvent);
+ ev.kind = c.UI_TRACKPAD_ROTATE;
+ ev.a = 20;
+ core.panes[core.active].?.body.mode = .insert;
+ dispatchTrackpad(&g, &in, &ev);
+ core.panes[core.active].?.body.mode = .tty;
+ dispatchTrackpad(&g, &in, &ev);
+ try std.testing.expectEqual(@as(usize, 0), client.pending.items.len);
+ ev.kind = c.UI_TRACKPAD_HISTORY;
+ ev.a = -1;
+ dispatchTrackpad(&g, &in, &ev);
+ ev.a = 1;
+ dispatchTrackpad(&g, &in, &ev);
+ try std.testing.expectEqual(@as(usize, 2), client.pending.items.len);
+ try std.testing.expectEqualStrings("Back", client.pending.items[0].command);
+ try std.testing.expectEqualStrings("Forward", client.pending.items[1].command);
+}
/// 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 };
@@ -4404,10 +4586,11 @@ const Shell = struct {
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) {
+ const native_gesture = if (comptime builtin.os.tag == .macos) sev.type == c.ui_macos_trackpad_event_type() else false;
+ if (!native_gesture) 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;
@@ -4561,7 +4744,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) and !pardes.views.isAway(s.core, k)) s.openAnotherWindow(k);
- s.windowed |= @as(u8, 1) << @intCast(live);
+ s.windowed |= @as(u8, 1) << @intCast(live);
}
s.core.toView(live);
s.follow();
@@ -4966,6 +5149,8 @@ fn pollFrame(ctx: ?*anyopaque) void {
s.reconcilePtys();
const core = s.core;
if (s.fs) |f| if (f.tick().pending) s.queue.push(.fs_ready);
+ // The authority owns its terminals even with its window closed.
+ pollCwds(core, s.ptys);
const g = s.gui orelse {
if (core.settings.window_opacity_pending) {
var unchanged_opacity: u8 = 100;
@@ -5008,7 +5193,6 @@ fn pollFrame(ctx: ?*anyopaque) void {
refitFont(g, core);
acknowledgeGuiFont(g, core);
}
- pollCwds(core, s.ptys);
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);
@@ -5635,6 +5819,43 @@ fn pollCwds(core: *pardes.Pardes, ptys: *[pardes.MAX_PANES]?Pty) void {
};
}
+test "a detached GUI authority follows terminal directory changes with no window" {
+ const gpa = std.testing.allocator;
+ const io = std.testing.io;
+ var tmp = std.testing.tmpDir(.{});
+ defer tmp.cleanup();
+ try tmp.dir.createDirPath(io, "child");
+ var start_buf: [4096]u8 = undefined;
+ const start = start_buf[0..try tmp.dir.realPath(io, &start_buf)];
+ var cwd_buf: [4096]u8 = undefined;
+ const expected = cwd_buf[0..try tmp.dir.realPathFile(io, "child", &cwd_buf)];
+ const core = try pardes.Pardes.init(gpa, .{ .tty_only = true });
+ defer core.deinit();
+ core.panes[0].?.shell_spoke = true;
+ _ = core.settings.shell.effective.set("/bin/sh");
+ var queue: Queue = .{ .io = 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);
+ const rcs: host_io.Shell.PromptFiles = .{};
+ var pipes: PipeTasks = .{};
+ var watches: file_watch.Table = @splat(null);
+ var shell: Shell = .{ .core = core, .io = io, .gpa = gpa, .lsp_allocator = gpa, .prompt_rcs = &rcs, .ptys = &ptys, .gens = &gens, .queue = &queue, .pipe_tasks = &pipes, .inotify_fd = -1, .watches = &watches };
+ defer shell.shutdownPtys();
+ const child = try host_io.forkShell(null, 0, &rcs, "/bin/sh", start, 24, 80, null);
+ ptys[0] = .{ .fd = child.file.handle, .pid = child.pid, .serial = core.panes[0].?.serial };
+ try std.testing.expect(host_io.writeFd(child.file.handle, "cd child\n"));
+ const until = std.Io.Clock.awake.now(io).toMilliseconds() + 2_000;
+ var actual: [4096]u8 = undefined;
+ while (std.Io.Clock.awake.now(io).toMilliseconds() < until) {
+ if (host_io.shellCwd(child.pid, &actual)) |cwd| if (std.mem.eql(u8, cwd, expected)) break;
+ try io.sleep(.fromMilliseconds(1), .awake);
+ }
+ try std.testing.expectEqualStrings(expected, host_io.shellCwd(child.pid, &actual) orelse return error.MissingCwd);
+ pollFrame(&shell);
+ try std.testing.expectEqualStrings(expected, core.panes[0].?.cwd.owned);
+}
+
fn accumulateWheelDelta(pending: f32, raw_y: f32) f32 {
if (!std.math.isFinite(raw_y)) return pending;
const next = pending - raw_y;
@@ -6278,21 +6499,73 @@ fn resetScroll(g: *Gui) void {
fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
stepGlide(g, core, gpa);
- const id = g.scroll_pane orelse return;
+ var in: Input = .{ .core = core };
+ _ = stepFractionalScroll(g, &in, gpa);
+}
+
+fn stepRemoteScroll(g: *Gui, in: *Input, gpa: std.mem.Allocator) bool {
+ return stepFractionalScroll(g, in, gpa);
+}
+
+test "detached trackpad scrolling keeps fractions local and queues whole rows for replication" {
+ const gpa = std.testing.allocator;
+ const core = try pardes.Pardes.init(gpa, .{ .cols = 60, .rows = 16 });
+ defer core.deinit();
+ _ = try core.setTestFile("one\ntwo\nthree\nfour\nfive\nsix\nseven\neight\nnine\nten\neleven\ntwelve\nthirteen\nfourteen\nfifteen\nsixteen\nseventeen\neighteen\nnineteen\ntwenty\n");
+ var arena: std.heap.ArenaAllocator = .init(gpa);
+ defer arena.deinit();
+ _ = try core.render(arena.allocator());
+ var client: Client = .{ .link = undefined, .io = std.testing.io, .gpa = gpa, .texts = .init(gpa) };
+ defer client.deinit();
+ var in: Input = .{ .core = core, .remote = &client };
+ const id = core.active;
+ const r = core.rects[id];
+ var g: Gui = undefined;
+ g.scroll_pane = id;
+ g.scroll_delta = 0.375;
+ g.scroll_lag = 0;
+ g.scroll_notch = 0;
+ g.scroll_edge = &.{};
+ g.scroll_edge_len = 0;
+ g.glide = .{};
+ g.scroll_col = r.x + config.GUTTER + 2;
+ g.scroll_row = core.bodyTop(core.panes[id].?, r) + 2;
+ defer gpa.free(g.scroll_edge);
+ const before = core.panes[id].?.scroll();
+ try std.testing.expect(stepRemoteScroll(&g, &in, gpa));
+ try std.testing.expectEqual(@as(usize, 1), client.pending.items.len);
+ // The next row is fetched early; its inverse raster offset preserves
+ // the exact fraction under the finger until that row is fully exposed.
+ try std.testing.expectEqual(@as(f32, 0.375), @as(f32, @floatFromInt(client.pending.items.len)) + g.scroll_lag);
+ try std.testing.expectEqual(before, core.panes[id].?.scroll());
+ core.update(client.pending.items[0]);
+ client.pending.clearRetainingCapacity();
+ g.scroll_delta = 0.75;
+ try std.testing.expect(stepRemoteScroll(&g, &in, gpa));
+ try std.testing.expectEqual(@as(usize, 1), client.pending.items.len);
+ try std.testing.expectEqual(before + 1, core.panes[id].?.scroll());
+ try std.testing.expect(client.pending.items[0].mouse.shift);
+ core.update(client.pending.items[0]);
+ try std.testing.expectEqual(@as(f32, 1.125), @as(f32, @floatFromInt(core.panes[id].?.scroll() - before)) + g.scroll_lag);
+}
+
+fn stepFractionalScroll(g: *Gui, in: *Input, gpa: std.mem.Allocator) bool {
+ const core = in.core orelse return false;
+ const id = g.scroll_pane orelse return false;
const pane = core.panes[id] orelse {
resetScroll(g);
- return;
+ return false;
};
const queued_delta = g.scroll_delta;
g.scroll_delta = 0;
if (queued_delta == 0) {
if (g.scroll_lag == 0 and g.scroll_notch == 0 and !g.glide.moving()) resetScroll(g);
- return;
+ return false;
}
const r = core.rects[id];
if (r.h <= pane.tag_rows) {
resetScroll(g);
- return;
+ return false;
}
const delta = boundScrollDelta(g.scroll_lag, queued_delta, r.h - pane.tag_rows);
const st = applyScrollDelta(g.scroll_lag, delta);
@@ -6301,7 +6574,7 @@ fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
const down = left > 0;
left += if (down) -1 else 1;
const was = pane.scroll();
- core.update(.{
+ in.post(.{
.mouse = .{
.button = if (down) .wheel_down else .wheel_up,
.kind = .press,
@@ -6310,9 +6583,11 @@ fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
.shift = true, // pardes's own scroll, never a program's wheel
},
});
- if (pane.scroll() == was) {
+ // A replica posts here and applies the batch after its view is
+ // parked again; its scroll cannot have changed yet.
+ if (in.remote == null and pane.scroll() == was) {
resetScroll(g);
- return;
+ return false;
}
}
g.scroll_lag = st.lag;
@@ -6341,6 +6616,7 @@ fn stepScroll(g: *Gui, core: *pardes.Pardes, gpa: std.mem.Allocator) void {
}
}
if (g.scroll_lag == 0) resetScroll(g);
+ return true;
}
fn emitScrollRows(g: *Gui, instances: [*]CellInstance, base: u32, surface: *pardes.Surface, layout: CellLayout, win_w: f32, win_h: f32, page: Ground, held: u16) u32 {