summaryrefslogtreecommitdiff
path: root/src/web.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/web.zig')
-rw-r--r--src/web.zig143
1 files changed, 56 insertions, 87 deletions
diff --git a/src/web.zig b/src/web.zig
index 7325af54..fd6371c0 100644
--- a/src/web.zig
+++ b/src/web.zig
@@ -1,7 +1,7 @@
//! Freestanding WebAssembly boundary for the DOM backend.
//!
//! JavaScript owns the clock and nothing else: it calls `pardes_tick` (one
-//! `Pardes.pump`) and reads the packed cell buffer `present` left behind. The
+//! `Pardes.pump`, at requestAnimationFrame's timestamp) and reads the packed cell buffer `present` left behind. The
//! host vtable below is only what a page genuinely has — pixels, the
//! clipboard, links, downloads. Processes, a real filesystem, a language
//! backend and subprocess pipes are left null, so the core answers them itself
@@ -10,62 +10,24 @@
const std = @import("std");
const pardes = @import("pardes.zig");
+const mouse = @import("mouse.zig");
const gpa = std.heap.wasm_allocator;
const embedded_dump = @embedFile("embedded.dump.zon");
const input_capacity = 64 * 1024;
-const c_alloc_header_size = 16;
const attr_tagline: u16 = 1 << 7;
+/// Tree-sitter's C runtime is linked into this module: its malloc, calloc,
+/// realloc and free are the wasm allocator's, as the Zig core's are. A var,
+/// as c_heap compares the allocator it is at run time (wasm_allocator's
+/// `ptr` is undefined, which comptime refuses to compare).
+var c_allocator: std.mem.Allocator = gpa;
+const c_heap = @import("c_heap").Heap(&c_allocator);
comptime {
- if (c_alloc_header_size < @sizeOf(usize)) @compileError("C allocation header is too small");
-}
-
-/// Tree-sitter's C runtime is linked into this module. Its conventional
-/// allocation symbols share the same wasm allocator as the Zig core and keep
-/// the original allocation size in a 16-byte, max-aligned prefix.
-export fn malloc(size_arg: usize) callconv(.c) ?*anyopaque {
- const size = @max(size_arg, 1);
- const total = std.math.add(usize, c_alloc_header_size, size) catch return null;
- const bytes = gpa.alignedAlloc(u8, .@"16", total) catch return null;
- const header: *align(16) usize = @ptrCast(bytes.ptr);
- header.* = total;
- return @ptrCast(bytes.ptr + c_alloc_header_size);
-}
-
-export fn calloc(count: usize, size: usize) callconv(.c) ?*anyopaque {
- const len = std.math.mul(usize, count, size) catch return null;
- const ptr = malloc(len) orelse return null;
- if (len != 0) {
- const bytes: [*]u8 = @ptrCast(ptr);
- @memset(bytes[0..len], 0);
- }
- return ptr;
-}
-
-export fn free(ptr: ?*anyopaque) callconv(.c) void {
- const data = ptr orelse return;
- const data_bytes: [*]u8 = @ptrCast(data);
- const base: [*]align(16) u8 = @ptrCast(@alignCast(data_bytes - c_alloc_header_size));
- const header: *align(16) usize = @ptrCast(base);
- gpa.free(base[0..header.*]);
-}
-
-export fn realloc(ptr: ?*anyopaque, size: usize) callconv(.c) ?*anyopaque {
- if (ptr == null) return malloc(size);
- if (size == 0) {
- free(ptr);
- return null;
- }
- const data_bytes: [*]u8 = @ptrCast(ptr.?);
- const base: [*]align(16) u8 = @ptrCast(@alignCast(data_bytes - c_alloc_header_size));
- const header: *align(16) usize = @ptrCast(base);
- const old_size = header.* - c_alloc_header_size;
- const replacement = malloc(size) orelse return null;
- const replacement_bytes: [*]u8 = @ptrCast(replacement);
- @memcpy(replacement_bytes[0..@min(old_size, size)], data_bytes[0..@min(old_size, size)]);
- free(ptr);
- return replacement;
+ @export(&c_heap.malloc, .{ .name = "malloc" });
+ @export(&c_heap.calloc, .{ .name = "calloc" });
+ @export(&c_heap.realloc, .{ .name = "realloc" });
+ @export(&c_heap.free, .{ .name = "free" });
}
pub const std_options: std.Options = .{ .logFn = logFn };
@@ -105,6 +67,9 @@ const State = struct {
frame_len: usize = 0,
frame_cols: u16 = 0,
frame_rows: u16 = 0,
+ /// requestAnimationFrame's timestamp as the last tick gave it, in ns:
+ /// the core's clock (`Host.now`).
+ now_ns: u64 = 0,
fn init(cols: u16, rows: u16) !State {
const allocs = pardes.memory.init(gpa);
@@ -116,7 +81,7 @@ const State = struct {
pardes.syntax.start(allocs.tree_sitter);
errdefer pardes.syntax.stop();
- const core = try pardes.Pardes.initFromDump(allocs.pardes, .{
+ const core = try pardes.dump.initFromDump(allocs.pardes, .{
.cols = cols,
.rows = rows,
.frame_allocator = allocs.frame,
@@ -220,13 +185,13 @@ export fn pardes_mouse_pixel(button_arg: u32, kind_arg: u32, col_arg: u32, row_a
var hit: ?pardes.Mouse.BodyHit = null;
for (&s.core.surface.body_layers) |*layer| {
const point = source orelse break;
- hit = layer.hitAt(point.x * bw, point.y * bh, bw, bh, tw, th);
+ hit = layer.bodyHit(point.x * bw, point.y * bh, bw, bh, tw, th);
if (hit != null) break;
}
var tag_hit: ?pardes.TagHit = null;
for (&s.core.surface.tag_layers) |*layer| {
const point = source orelse break;
- tag_hit = layer.hitAt(point.x * bw, point.y * bh, bw, bh, tw, th);
+ tag_hit = layer.tagHit(point.x * bw, point.y * bh, bw, bh, tw, th);
if (tag_hit != null) break;
}
mouseWithHit(button_arg, kind_arg, col_arg, row_arg, mods, hit, tag_hit);
@@ -254,15 +219,20 @@ fn mouseWithHit(button_arg: u32, kind_arg: u32, col_arg: u32, row_arg: u32, mods
3 => .drag,
else => return,
};
- s.core.update(.{ .mouse = .{
- .body_hit = hit,
- .tag_hit = tag_hit,
- .button = button,
- .kind = kind,
- .col = @intCast(@min(col_arg, std.math.maxInt(u16))),
- .row = @intCast(@min(row_arg, std.math.maxInt(u16))),
- .ctrl = mods & 1 != 0,
- } });
+ s.core.update(.{
+ .mouse = .{
+ .body_hit = hit,
+ .tag_hit = tag_hit,
+ .button = button,
+ .kind = kind,
+ .col = @intCast(@min(col_arg, std.math.maxInt(u16))),
+ .row = @intCast(@min(row_arg, std.math.maxInt(u16))),
+ .ctrl = mods & 1 != 0,
+ // Alt-click is B2 and Cmd/Super-click B3 (mouse.emulateButton).
+ .alt = mods & 2 != 0,
+ .super = mods & 8 != 0,
+ },
+ });
}
export fn pardes_touch_scroll(delta: f32) void {
@@ -275,30 +245,19 @@ export fn pardes_pointer_leave() void {
s.core.update(.pointer_leave);
}
-/// One iteration of the core's own loop: queued input, effects, render,
-/// present. JS calls it once per animation frame, after spending that frame's
-/// animation ticks.
-export fn pardes_tick() void {
+/// One iteration of the core's own loop: queued input, effects, the frames
+/// of animation `timestamp_ms` (requestAnimationFrame's clock) has brought,
+/// render, present. JS calls it once per display frame; a call with no
+/// timestamp (NaN) leaves the clock where it was.
+export fn pardes_tick(timestamp_ms: f64) void {
const s = &(state orelse return);
+ if (std.math.isFinite(timestamp_ms) and timestamp_ms >= 0)
+ s.now_ns = @intFromFloat(timestamp_ms * std.time.ns_per_ms);
s.core.pump(host(s)) catch |err| {
last_error = @intFromError(err);
};
}
-/// Spend one fixed 60 Hz animation step, the only writer of animated time in
-/// this host. Separate from the pump for the reason the AppKit shell keeps them
-/// separate: if every input pump also advanced the transition, a burst of keys
-/// would collapse a ten-frame fade into one display frame.
-export fn pardes_animation_tick() void {
- const s = &(state orelse return);
- s.core.update(.tick);
-}
-
-export fn pardes_animating() u32 {
- const s = &(state orelse return 0);
- return @intFromBool(s.core.animationActive());
-}
-
/// The Exit builtin, or the last pane closing. JS stops its frame loop.
export fn pardes_should_quit() u32 {
const s = &(state orelse return 0);
@@ -348,18 +307,22 @@ export fn pardes_tag_layer_value(index: u32, field: u32) u32 {
const s = &(state orelse return 0);
if (index >= pardes.MAX_TAG_LAYERS) return 0;
const layer = &s.core.surface.tag_layers[index];
+ if (layer.rows == 0) return 0;
return switch (field) {
0 => layer.cols,
- 1 => @intFromEnum(layer.kind),
+ 1 => @backingInt(layer.kind),
2 => layer.id,
3 => layer.serial,
4 => layer.viewport.x,
5 => layer.viewport.y,
6 => layer.viewport.w,
7 => layer.viewport.h,
- 8 => if (layer.cursor) |c| c.col else 65535,
+ 8 => if (layer.cursor) |c| c.x else 65535,
9 => if (layer.cursor) |c| @intFromBool(c.bar) else 0,
10 => @as(u32, layer.bg[0]) << 16 | @as(u32, layer.bg[1]) << 8 | layer.bg[2],
+ // A band has a row to each line of its tag: `cols * rows` cells.
+ 11 => layer.rows,
+ 12 => if (layer.cursor) |c| c.y else 65535,
else => 0,
};
}
@@ -368,7 +331,7 @@ export fn pardes_tag_layer_cells(index: u32) ?[*]const WebCell {
const s = &(state orelse return null);
if (index >= pardes.MAX_TAG_LAYERS) return null;
const layer = &s.core.surface.tag_layers[index];
- if (layer.cols == 0) return null;
+ if (layer.rows == 0) return null;
const cells = &s.tag_cells[index];
if (cells.len != layer.cells.len) cells.* = gpa.realloc(cells.*, layer.cells.len) catch return null;
for (layer.cells, cells.*) |source, *out| out.* = encodeWebCell(source);
@@ -376,7 +339,7 @@ export fn pardes_tag_layer_cells(index: u32) ?[*]const WebCell {
}
export fn pardes_tagline_band_offset(row: u16, canvas_h: f32, cell_h: u32, tagline_h: u32) u32 {
- return pardes.taglineBandOffset(row, canvas_h, cell_h, tagline_h, true);
+ return pardes.taglineBandOffset(row, canvas_h, cell_h, tagline_h);
}
export fn pardes_body_layer_value(index: u32, field: u32) u32 {
@@ -421,7 +384,7 @@ export fn pardes_row_metrics(body_w: u16, body_h: u16, tagline_w: u16, tagline_h
export fn pardes_pointer_shape() u32 {
const s = &(state orelse return 0);
- return @intFromEnum(s.core.surface.pointer_shape);
+ return @backingInt(s.core.surface.pointer_shape);
}
export fn pardes_cursor_y() i32 {
@@ -441,7 +404,7 @@ export fn pardes_chrome_target(col_arg: u32, row_arg: u32) u32 {
const s = &(state orelse return std.math.maxInt(u32));
const col: u16 = @intCast(@min(col_arg, std.math.maxInt(u16)));
const row: u16 = @intCast(@min(row_arg, std.math.maxInt(u16)));
- const target = s.core.chromeTarget(col, row) orelse return std.math.maxInt(u32);
+ const target = mouse.chromeTarget(s.core, col, row) orelse return std.math.maxInt(u32);
return (@as(u32, target.row) << 16) | target.col;
}
@@ -461,7 +424,13 @@ extern "pardes" fn host_download(
bytes_len: usize,
) callconv(.c) void;
+fn now(ctx: ?*anyopaque) u64 {
+ const s: *State = @ptrCast(@alignCast(ctx.?));
+ return s.now_ns;
+}
+
const vtable: pardes.Host.VTable = .{
+ .now = now,
.present = present,
.write_file = writeFile,
.write_dump = writeDump,
@@ -551,6 +520,6 @@ fn encodeAttrs(style: pardes.CellStyle) u16 {
attrs |= @as(u16, @intFromBool(style.invisible)) << 5;
attrs |= @as(u16, @intFromBool(style.strikethrough)) << 6;
attrs |= @as(u16, @intFromBool(style.font_role == .tagline)) * attr_tagline;
- attrs |= @as(u16, @intFromEnum(style.ul)) << 8;
+ attrs |= @as(u16, @backingInt(style.ul)) << 8;
return attrs;
}