init

pub fn init(
    pointer: anytype,
    comptime dataFn: fn (ptr: @TypeOf(pointer)) *WidgetData,
    comptime rectForFn: fn (ptr: @TypeOf(pointer), id: Id, min_size: Size, e: Options.Expand, g: Options.Gravity) Rect,
    comptime screenRectScaleFn: fn (ptr: @TypeOf(pointer), r: Rect) RectScale,
    comptime minSizeForChildFn: fn (ptr: @TypeOf(pointer), s: Size) void,
) Widget {
    const Ptr = @TypeOf(pointer);
    const ptr_info = @typeInfo(Ptr);
    std.debug.assert(ptr_info == .pointer); // Must be a pointer
    std.debug.assert(ptr_info.pointer.size == .one); // Must be a single-item pointer

    const gen = struct {
        fn dataImpl(ptr: *anyopaque) *WidgetData {
            const self = @as(Ptr, @ptrCast(@alignCast(ptr)));
            return @call(.always_inline, dataFn, .{self});
        }

        fn rectForImpl(ptr: *anyopaque, id: Id, min_size: Size, e: Options.Expand, g: Options.Gravity) Rect {
            const self = @as(Ptr, @ptrCast(@alignCast(ptr)));
            return @call(.always_inline, rectForFn, .{ self, id, min_size, e, g });
        }

        fn screenRectScaleImpl(ptr: *anyopaque, r: Rect) RectScale {
            const self = @as(Ptr, @ptrCast(@alignCast(ptr)));
            return @call(.always_inline, screenRectScaleFn, .{ self, r });
        }

        fn minSizeForChildImpl(ptr: *anyopaque, s: Size) void {
            const self = @as(Ptr, @ptrCast(@alignCast(ptr)));
            return @call(.always_inline, minSizeForChildFn, .{ self, s });
        }

        const vtable = VTable{
            .data = dataImpl,
            .rectFor = rectForImpl,
            .screenRectScale = screenRectScaleImpl,
            .minSizeForChild = minSizeForChildImpl,
        };
    };

    return .{
        .ptr = pointer,
        .vtable = &gen.vtable,
    };
}