Backlog/lib/sdl3/v2/keyboard.zig

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

pub const Scancode = enum(c_int) {
    scancodeUnknown,
    scancodeA,
    scancodeB,
    scancodeC,
    scancodeD,
    scancodeE,
    scancodeF,
    scancodeG,
    scancodeH,
    scancodeI,
    scancodeJ,
    scancodeK,
    scancodeL,
    scancodeM,
    scancodeN,
    scancodeO,
    scancodeP,
    scancodeQ,
    scancodeR,
    scancodeS,
    scancodeT,
    scancodeU,
    scancodeV,
    scancodeW,
    scancodeX,
    scancodeY,
    scancodeZ,
    scancode1,
    scancode2,
    scancode3,
    scancode4,
    scancode5,
    scancode6,
    scancode7,
    scancode8,
    scancode9,
    scancode0,
    scancodeReturn,
    scancodeEscape,
    scancodeBackspace,
    scancodeTab,
    scancodeSpace,
    scancodeMinus,
    scancodeEquals,
    scancodeLeftbracket,
    scancodeRightbracket,
    scancodeSemicolon,
    scancodeApostrophe,
    scancodeComma,
    scancodePeriod,
    scancodeSlash,
    scancodeCapslock,
    scancodeF1,
    scancodeF2,
    scancodeF3,
    scancodeF4,
    scancodeF5,
    scancodeF6,
    scancodeF7,
    scancodeF8,
    scancodeF9,
    scancodeF10,
    scancodeF11,
    scancodeF12,
    scancodePrintscreen,
    scancodeScrolllock,
    scancodePause,
    scancodeHome,
    scancodePageup,
    scancodeDelete,
    scancodeEnd,
    scancodePagedown,
    scancodeRight,
    scancodeLeft,
    scancodeDown,
    scancodeUp,
    scancodeKpDivide,
    scancodeKpMultiply,
    scancodeKpMinus,
    scancodeKpPlus,
    scancodeKpEnter,
    scancodeKp1,
    scancodeKp2,
    scancodeKp3,
    scancodeKp4,
    scancodeKp5,
    scancodeKp6,
    scancodeKp7,
    scancodeKp8,
    scancodeKp9,
    scancodeKp0,
    scancodeKpPeriod,
    scancodeKpEquals,
    scancodeF13,
    scancodeF14,
    scancodeF15,
    scancodeF16,
    scancodeF17,
    scancodeF18,
    scancodeF19,
    scancodeF20,
    scancodeF21,
    scancodeF22,
    scancodeF23,
    scancodeF24,
    scancodeExecute,
    scancodeSelect,
    scancodeMute,
    scancodeVolumeup,
    scancodeVolumedown,
    scancodeKpComma,
    scancodeKpEqualsas400,
    scancodeInternational2,
    scancodeInternational4,
    scancodeInternational5,
    scancodeInternational6,
    scancodeInternational7,
    scancodeInternational8,
    scancodeInternational9,
    scancodeSysreq,
    scancodeClear,
    scancodePrior,
    scancodeReturn2,
    scancodeSeparator,
    scancodeOut,
    scancodeOper,
    scancodeClearagain,
    scancodeCrsel,
    scancodeExsel,
    scancodeKp00,
    scancodeKp000,
    scancodeThousandsseparator,
    scancodeDecimalseparator,
    scancodeCurrencyunit,
    scancodeCurrencysubunit,
    scancodeKpLeftparen,
    scancodeKpRightparen,
    scancodeKpLeftbrace,
    scancodeKpRightbrace,
    scancodeKpTab,
    scancodeKpBackspace,
    scancodeKpA,
    scancodeKpB,
    scancodeKpC,
    scancodeKpD,
    scancodeKpE,
    scancodeKpF,
    scancodeKpXor,
    scancodeKpPower,
    scancodeKpPercent,
    scancodeKpLess,
    scancodeKpGreater,
    scancodeKpAmpersand,
    scancodeKpDblampersand,
    scancodeKpVerticalbar,
    scancodeKpDblverticalbar,
    scancodeKpColon,
    scancodeKpHash,
    scancodeKpSpace,
    scancodeKpAt,
    scancodeKpExclam,
    scancodeKpMemstore,
    scancodeKpMemrecall,
    scancodeKpMemclear,
    scancodeKpMemadd,
    scancodeKpMemsubtract,
    scancodeKpMemmultiply,
    scancodeKpMemdivide,
    scancodeKpPlusminus,
    scancodeKpClear,
    scancodeKpClearentry,
    scancodeKpBinary,
    scancodeKpOctal,
    scancodeKpDecimal,
    scancodeKpHexadecimal,
    scancodeLctrl,
    scancodeLshift,
    scancodeRctrl,
    scancodeRshift,
};

pub const Window = opaque {
    pub inline fn startTextInput(window: *Window) bool {
        return c.SDL_StartTextInput(window);
    }

    pub inline fn startTextInputWithProperties(window: *Window, props: PropertiesID) bool {
        return c.SDL_StartTextInputWithProperties(window, props);
    }

    pub inline fn textInputActive(window: *Window) bool {
        return c.SDL_TextInputActive(window);
    }

    pub inline fn stopTextInput(window: *Window) bool {
        return c.SDL_StopTextInput(window);
    }

    pub inline fn clearComposition(window: *Window) bool {
        return c.SDL_ClearComposition(window);
    }

    pub inline fn setTextInputArea(window: *Window, rect: *const Rect, cursor: c_int) bool {
        return c.SDL_SetTextInputArea(window, @ptrCast(rect), cursor);
    }

    pub inline fn getTextInputArea(window: *Window, rect: ?*Rect, cursor: *c_int) bool {
        return c.SDL_GetTextInputArea(window, rect, @ptrCast(cursor));
    }

    pub inline fn screenKeyboardShown(window: *Window) bool {
        return c.SDL_ScreenKeyboardShown(window);
    }
};

pub const Keymod = u16;

pub const Rect = extern struct {
    x: c_int,
    y: c_int,
    w: c_int,
    h: c_int,
};

pub const Keycode = u32;

pub const PropertiesID = u32;

pub const KeyboardID = u32;

pub inline fn hasKeyboard() bool {
    return c.SDL_HasKeyboard();
}

pub inline fn getKeyboards(count: *c_int) ?*KeyboardID {
    return c.SDL_GetKeyboards(@ptrCast(count));
}

pub inline fn getKeyboardNameForID(instance_id: KeyboardID) [*c]const u8 {
    return c.SDL_GetKeyboardNameForID(instance_id);
}

pub inline fn getKeyboardFocus() ?*Window {
    return c.SDL_GetKeyboardFocus();
}

pub inline fn getKeyboardState(numkeys: *c_int) *const bool {
    return @ptrCast(c.SDL_GetKeyboardState(@ptrCast(numkeys)));
}

pub inline fn resetKeyboard() void {
    return c.SDL_ResetKeyboard();
}

pub inline fn getModState() Keymod {
    return c.SDL_GetModState();
}

pub inline fn setModState(modstate: Keymod) void {
    return c.SDL_SetModState(modstate);
}

pub inline fn getKeyFromScancode(scancode: Scancode, modstate: Keymod, key_event: bool) Keycode {
    return c.SDL_GetKeyFromScancode(scancode, modstate, key_event);
}

pub inline fn getScancodeFromKey(key: Keycode, modstate: ?*Keymod) Scancode {
    return c.SDL_GetScancodeFromKey(key, modstate);
}

pub inline fn setScancodeName(scancode: Scancode, name: [*c]const u8) bool {
    return c.SDL_SetScancodeName(scancode, name);
}

pub inline fn getScancodeName(scancode: Scancode) [*c]const u8 {
    return c.SDL_GetScancodeName(scancode);
}

pub inline fn getScancodeFromName(name: [*c]const u8) Scancode {
    return c.SDL_GetScancodeFromName(name);
}

pub inline fn getKeyName(key: Keycode) [*c]const u8 {
    return c.SDL_GetKeyName(key);
}

pub inline fn getKeyFromName(name: [*c]const u8) Keycode {
    return c.SDL_GetKeyFromName(name);
}

pub const TextInputType = enum(c_int) {};

pub const Capitalization = enum(c_int) {};

pub inline fn hasScreenKeyboardSupport() bool {
    return c.SDL_HasScreenKeyboardSupport();
}