Backlog/lib/sdl3/v2/events.zig

const std = @import("std");
pub const c = @import("c.zig").c;

pub const Window = opaque {};

pub const FingerID = u64;

pub const EventType = enum(c_int) {
    eventDisplayFirst,
    eventDisplayLast,
    eventWindowFirst,
    eventWindowLast,
    eventFingerDown,
    eventFingerUp,
    eventFingerMotion,
    eventFingerCanceled,
    eventPrivate0,
    eventPrivate1,
    eventPrivate2,
    eventPrivate3,
    eventUser,
    eventLast,
    eventEnumPadding,
};

pub const CommonEvent = extern struct {
    reserved: u32,
};

pub const DisplayEvent = extern struct {
    reserved: u32,
};

pub const WindowEvent = extern struct {
    reserved: u32,
};

pub const KeyboardDeviceEvent = extern struct {
    reserved: u32,
};

pub const KeyboardEvent = extern struct {
    reserved: u32,
};

pub const TextEditingEvent = extern struct {
    reserved: u32,
};

pub const TextEditingCandidatesEvent = extern struct {
    reserved: u32,
    padding1: u8,
    padding2: u8,
    padding3: u8,
};

pub const TextInputEvent = extern struct {
    reserved: u32,
};

pub const MouseDeviceEvent = extern struct {
    reserved: u32,
};

pub const MouseMotionEvent = extern struct {
    reserved: u32,
};

pub const MouseButtonEvent = extern struct {
    reserved: u32,
    padding: u8,
};

pub const MouseWheelEvent = extern struct {
    reserved: u32,
};

pub const JoyAxisEvent = extern struct {
    reserved: u32,
    padding1: u8,
    padding2: u8,
    padding3: u8,
    padding4: u16,
};

pub const JoyBallEvent = extern struct {
    reserved: u32,
    padding1: u8,
    padding2: u8,
    padding3: u8,
};

pub const JoyHatEvent = extern struct {
    reserved: u32,
    padding1: u8,
    padding2: u8,
};

pub const JoyButtonEvent = extern struct {
    reserved: u32,
    padding1: u8,
    padding2: u8,
};

pub const JoyDeviceEvent = extern struct {
    reserved: u32,
};

pub const JoyBatteryEvent = extern struct {
    reserved: u32,
};

pub const GamepadAxisEvent = extern struct {
    reserved: u32,
    padding1: u8,
    padding2: u8,
    padding3: u8,
    padding4: u16,
};

pub const GamepadButtonEvent = extern struct {
    reserved: u32,
    padding1: u8,
    padding2: u8,
};

pub const GamepadDeviceEvent = extern struct {
    reserved: u32,
};

pub const GamepadTouchpadEvent = extern struct {
    reserved: u32,
};

pub const GamepadSensorEvent = extern struct {
    reserved: u32,
};

pub const AudioDeviceEvent = extern struct {
    reserved: u32,
    padding1: u8,
    padding2: u8,
    padding3: u8,
};

pub const CameraDeviceEvent = extern struct {
    reserved: u32,
};

pub const RenderEvent = extern struct {
    reserved: u32,
};

pub const TouchFingerEvent = extern struct {
    reserved: u32,
    fingerID: FingerID,
};

pub const PenProximityEvent = extern struct {
    reserved: u32,
};

pub const PenMotionEvent = extern struct {
    reserved: u32,
};

pub const PenTouchEvent = extern struct {
    reserved: u32,
};

pub const PenButtonEvent = extern struct {
    reserved: u32,
};

pub const PenAxisEvent = extern struct {
    reserved: u32,
};

pub const DropEvent = extern struct {
    reserved: u32,
};

pub const ClipboardEvent = extern struct {
    reserved: u32,
};

pub const SensorEvent = extern struct {
    reserved: u32,
};

pub const QuitEvent = extern struct {
    reserved: u32,
};

pub const UserEvent = extern struct {
    reserved: u32,
};

pub const Event = union;

pub inline fn pumpEvents() void {
    return c.SDL_PumpEvents();
}

pub const EventAction = enum(c_int) {
};

pub inline fn peepEvents(events: ?*Event, numevents: c_int, action: EventAction, minType: u32, maxType: u32,) c_int {
    return c.SDL_PeepEvents(events, numevents, action, minType, maxType);
}

pub inline fn hasEvent(type: u32) bool {
    return c.SDL_HasEvent(type);
}

pub inline fn hasEvents(minType: u32, maxType: u32) bool {
    return c.SDL_HasEvents(minType, maxType);
}

pub inline fn flushEvent(type: u32) void {
    return c.SDL_FlushEvent(type);
}

pub inline fn flushEvents(minType: u32, maxType: u32) void {
    return c.SDL_FlushEvents(minType, maxType);
}

pub inline fn pollEvent(event: ?*Event) bool {
    return c.SDL_PollEvent(event);
}

pub inline fn waitEvent(event: ?*Event) bool {
    return c.SDL_WaitEvent(event);
}

pub inline fn waitEventTimeout(event: ?*Event, timeoutMS: i32) bool {
    return c.SDL_WaitEventTimeout(event, timeoutMS);
}

pub inline fn pushEvent(event: ?*Event) bool {
    return c.SDL_PushEvent(event);
}

pub const EventFilter = *const fn(userdata: ?*anyopaque, event: ?*Event) callconv(.C) bool;

pub inline fn setEventFilter(filter: EventFilter, userdata: ?*anyopaque) void {
    return c.SDL_SetEventFilter(filter, userdata);
}

pub inline fn getEventFilter(filter: ?*EventFilter, userdata: [*c]?*anyopaque) bool {
    return c.SDL_GetEventFilter(filter, userdata);
}

pub inline fn addEventWatch(filter: EventFilter, userdata: ?*anyopaque) bool {
    return c.SDL_AddEventWatch(filter, userdata);
}

pub inline fn removeEventWatch(filter: EventFilter, userdata: ?*anyopaque) void {
    return c.SDL_RemoveEventWatch(filter, userdata);
}

pub inline fn filterEvents(filter: EventFilter, userdata: ?*anyopaque) void {
    return c.SDL_FilterEvents(filter, userdata);
}

pub inline fn setEventEnabled(type: u32, enabled: bool) void {
    return c.SDL_SetEventEnabled(type, enabled);
}

pub inline fn eventEnabled(type: u32) bool {
    return c.SDL_EventEnabled(type);
}

pub inline fn registerEvents(numevents: c_int) u32 {
    return c.SDL_RegisterEvents(numevents);
}

pub inline fn getWindowFromEvent(event: *const Event) ?*Window {
    return c.SDL_GetWindowFromEvent(@ptrCast(event));
}