tiny.ui.fact

1pub const Clip = extern struct {2    rect: abi.Rect = .{},3    origin_x: f32 = 0,4    origin_y: f32 = 0,5    scroll_x: f32 = 0,6    scroll_y: f32 = 0,7    parent: u32 = 0,8    flags: u32 = 0,9};

1pub const Cluster = extern struct {2    byte_start: u32 = 0,3    byte_end: u32 = 0,4    advance: f32 = 0,5    glyph: u32 = 0,6    face: u32 = 0,7    columns: u8 = 0,8    flags: u8 = 0,9    _pad: u16 = 0,10};

1pub const Fact = extern struct {2    id: u64 = 0,3    revision: u64 = 0,4    rect: abi.Rect = .{},5    clip: u32 = 0,6    paint: u32 = 0,7    text: u32 = 0,8    state: u32 = 0,9    role: u16 = 0,10    kind: u16 = 0,11    flags: u16 = 0,12    focus_index: u16 = 0xffff,13    name: u32 = 0,14    action: u32 = 0,15};

1pub const TextLayout = extern struct {2    line_first: u32 = 0,3    line_count: u32 = 0,4    width: f32 = 0,5    height: f32 = 0,6};

1pub const TextLine = extern struct {2    span_first: u32 = 0,3    span_count: u32 = 0,4    origin_x: f32 = 0,5    baseline_y: f32 = 0,6    width: f32 = 0,7    height: f32 = 0,8};

1pub const TextSpan = extern struct {2    cluster_first: u32 = 0,3    cluster_count: u32 = 0,4    origin_x: f32 = 0,5    width: f32 = 0,6    paint: u32 = 0,7    text_style: u32 = 0,8};

1pub const TextTables = struct {2    layouts: []const TextLayout,3    lines: []const TextLine,4    spans: []const TextSpan,5    clusters: []const Cluster,6};

1pub const UnitMetrics = extern struct {2    device_per_unit_x: f32 = 1,3    device_per_unit_y: f32 = 1,4    snap_x: f32 = 1,5    snap_y: f32 = 1,6    root_font_size: f32 = 16,7    cell_advance: f32 = 1,8    cell_height: f32 = 1,9    flags: u32 = 0,10};

1pub const Store = struct {2    pub const claim: alloc_phase.capacity.Declaration = .{3        .source = .{4            .id = "ui.fact_store",5            .kind = .phase_static,6            .limit_source = .caller,7            .storage = .{8                .covered = &.{.{9                    .id = "retained_fact_arrays",10                    .lifetime = .steady,11                    .detail = "two arrays of Limits.nodes Fact records; the current and prior frame occupy one array each",12                }},13                .excluded = &.{14                    "the tree store's node identity map and the damage owner's changed-node list",15                    "paint, image, text, and clip tables owned by their respective emitters",16                },17            },18            .capacity = .{19                .inputs = &.{alloc_phase.capacity.bindInput(Limits, "nodes", "nodes")},20                .type_selectors = &.{alloc_phase.capacity.bindType(Fact, "fact")},21                .nodes = &.{22                    .{ .input = 0 },23                    .{ .scale = .{ .node = 0, .coefficient = .{ .size_of_concrete_type = 0 } } },24                    .{ .add = .{ .left = 1, .right = 1 } },25                },26                .assertions = &.{.{27                    .scope = .closure_total,28                    .measure = .retained,29                    .relation = .exact,30                    .expression = 2,31                }},32            },33            .overload = .{34                .kind = .reject_before_seal,35                .detail = "publish rejects a fact count above Limits.nodes before writing either retained array",36            },37            .risks = .{38                .transitive = .{39                    .status = .open,40                    .detail = "publish copies caller facts without an allocator; a machine certificate of the call graph remains open",41                },42                .foreign = .{43                    .status = .excluded,44                    .detail = "fact emission is an in-process copy and calls no foreign runtime",45                },46            },47            .obligations = &.{48                .{ .key = "ui_fact_capacity", .role = .capacity_model },49                .{ .key = "ui_fact_acquisition", .role = .acquisition },50                .{ .key = "ui_fact_oom", .role = .initialization_failure },51                .{ .key = "ui_fact_teardown", .role = .teardown },52            },53        },54        .bindings = .{55            .owner = @This(),56            .seal = .{57                .family = alloc_phase.capacity.selector(@This().activate),58                .premise = .{ .class = .checked_semantic_fact, .authority = .checker },59            },60            .teardown = .{61                .family = alloc_phase.capacity.selector(@This().deinit),62                .premise = .{ .class = .checked_semantic_fact, .authority = .checker },63            },64        },65    };6667    phase: alloc_phase.capacity.Phase,68    limits: Limits,69    capacity: Capacity,70    storage: []Fact,71    arrays: [2][]Fact,72    counts: [2]u32 = @splat(0),73    live: u1 = 0,7475    pub fn init(allocator: Allocator, limits: Limits) (error{CapacityOverflow} || Allocator.Error)!Store {76        const capacity = try Capacity.derive(limits);77        const count = std.math.mul(usize, limits.nodes, 2) catch return error.CapacityOverflow;78        const storage = try allocator.alloc(Fact, count);79        return .{80            .phase = .initialization,81            .limits = limits,82            .capacity = capacity,83            .storage = storage,84            .arrays = .{ storage[0..limits.nodes], storage[limits.nodes..] },85        };86    }8788    pub fn activate(self: *Store) void {89        std.debug.assert(self.phase == .initialization);90        self.phase = .steady;91    }9293    pub fn publish(self: *Store, facts: []const Fact) error{FactCapacityExceeded}!void {94        std.debug.assert(self.phase == .steady);95        if (facts.len > self.limits.nodes) return error.FactCapacityExceeded;96        const next = self.live ^ 1;97        @memcpy(self.arrays[next][0..facts.len], facts);98        self.counts[next] = @intCast(facts.len);99        self.live = next;100    }101102    pub fn retained(self: *const Store) []const Fact {103        std.debug.assert(self.phase == .steady);104        return self.arrays[self.live][0..self.counts[self.live]];105    }106107    pub fn prior(self: *const Store) []const Fact {108        std.debug.assert(self.phase == .steady);109        const other = self.live ^ 1;110        return self.arrays[other][0..self.counts[other]];111    }112113    pub fn deinit(self: *Store, allocator: Allocator) void {114        std.debug.assert(self.phase != .teardown);115        self.phase = .teardown;116        allocator.free(self.storage);117        self.storage = &.{};118    }119};

1pub fn deviceRect(rect: abi.Rect, metrics: UnitMetrics) abi.IRect {2    std.debug.assert(std.math.isFinite(rect.x));3    std.debug.assert(std.math.isFinite(rect.y));4    std.debug.assert(std.math.isFinite(rect.width));5    std.debug.assert(std.math.isFinite(rect.height));6    std.debug.assert(rect.width >= 0);7    std.debug.assert(rect.height >= 0);8    std.debug.assert(metrics.device_per_unit_x > 0);9    std.debug.assert(metrics.device_per_unit_y > 0);10    std.debug.assert(metrics.snap_x > 0);11    std.debug.assert(metrics.snap_y > 0);12    std.debug.assert(std.math.isFinite(metrics.device_per_unit_x));13    std.debug.assert(std.math.isFinite(metrics.device_per_unit_y));14    std.debug.assert(std.math.isFinite(metrics.snap_x));15    std.debug.assert(std.math.isFinite(metrics.snap_y));16    const left = @floor(rect.x * metrics.device_per_unit_x / metrics.snap_x) * metrics.snap_x;17    const top = @floor(rect.y * metrics.device_per_unit_y / metrics.snap_y) * metrics.snap_y;18    const right = @ceil((rect.x + rect.width) * metrics.device_per_unit_x / metrics.snap_x) *19        metrics.snap_x;20    const bottom = @ceil((rect.y + rect.height) * metrics.device_per_unit_y / metrics.snap_y) *21        metrics.snap_y;22    std.debug.assert(left >= std.math.minInt(i32));23    std.debug.assert(top >= std.math.minInt(i32));24    std.debug.assert(right < 2_147_483_648);25    std.debug.assert(bottom < 2_147_483_648);26    std.debug.assert(right >= left);27    std.debug.assert(bottom >= top);28    std.debug.assert(right - left < 4_294_967_296);29    std.debug.assert(bottom - top < 4_294_967_296);30    return .{31        .x = @intFromFloat(left),32        .y = @intFromFloat(top),33        .width = @intFromFloat(right - left),34        .height = @intFromFloat(bottom - top),35    };36}

1const records = @import("records.zig");2const unit = @import("unit.zig");34pub const Fact = records.Fact;5pub const Clip = records.Clip;6pub const Paint = records.Paint;7pub const ImagePaint = records.ImagePaint;8pub const TextStyle = records.TextStyle;9pub const TextLayout = records.TextLayout;10pub const TextLine = records.TextLine;11pub const TextSpan = records.TextSpan;12pub const Cluster = records.Cluster;13pub const TextTables = records.TextTables;14pub const UnitMetrics = records.UnitMetrics;15pub const deviceRect = unit.deviceRect;16pub const Store = @import("store.zig").Store;

1pub const fact = @import("fact/root.zig");