Skip to content

std.os.uefi.protocol.simple_text_input_ex

Standard libraryZig 0.17.0Official documentation
Sourcestd/os/uefi/protocol/simple_text_input_ex.zig

Source line 1

std.os.uefi.protocol.simple_text_input_ex.cc

alias

Source line 6

Alias of std.os.uefi.cc

std.os.uefi.protocol.simple_text_input_ex.Event

alias

Source line 3

Alias of std.os.uefi.Event

std.os.uefi.protocol.simple_text_input_ex.Guid

alias

Source line 4

Alias of std.os.uefi.Guid

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx

container

Source line 9

Character input devices, e.g. Keyboard

Fields

_reset: *const fn (*SimpleTextInputEx, bool) callconv(cc) Status
_read_key_stroke_ex: *const fn (*SimpleTextInputEx, *Key) callconv(cc) Status
wait_for_key_ex: Event
_set_state: *const fn (*SimpleTextInputEx, *const u8) callconv(cc) Status
_register_key_notify: *const fn (*SimpleTextInputEx, *const Key, *const fn (*const Key) callconv(cc) Status, **anyopaque) callconv(cc) Status
_unregister_key_notify: *const fn (*SimpleTextInputEx, *const anyopaque) callconv(cc) Status

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.guid

constant

Source line 87

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.Key

container

Source line 96

Fields

input: Input
state: State

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.Key.Input

container

Source line 129

Fields

scan_code: u16
unicode_char: u16

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.Key.State

container

Source line 100

Fields

shift: Shift
toggle: Toggle

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.Key.State.Shift

container

Source line 104

Fields

right_shift_pressed: bool
left_shift_pressed: bool
right_control_pressed: bool
left_control_pressed: bool
right_alt_pressed: bool
left_alt_pressed: bool
right_logo_pressed: bool
left_logo_pressed: bool
menu_key_pressed: bool
sys_req_pressed: bool
_pad: u21 = 0
shift_state_valid: bool

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.Key.State.Toggle

container

Source line 119

Fields

scroll_lock_active: bool
num_lock_active: bool
caps_lock_active: bool
_pad: u3 = 0
key_state_exposed: bool
toggle_state_valid: bool

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.readKeyStroke

function

Source line 40

Reads the next keystroke from the input device.

pub fn readKeyStroke(self: *SimpleTextInputEx) ReadKeyStrokeError!Key

Parameters

Errors

DeviceError
NotReady
Unexpected UnexpectedError
Unsupported

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.ReadKeyStrokeError

error-set

Source line 18

Errors

DeviceError
NotReady
Unexpected UnexpectedError
Unsupported

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.registerKeyNotify

function

Source line 62

Register a notification function for a particular keystroke for the input device.

pub fn registerKeyNotify( self: *SimpleTextInputEx, key_data: *const Key, notify: *const fn (*const Key) callconv(cc) Status, ) RegisterKeyNotifyError!uefi.Handle

Parameters

self: *SimpleTextInputEx
key_data: *const Key
notify: *const fn (*const Key) callconv(cc) Status

Errors

OutOfResources
Unexpected UnexpectedError

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.RegisterKeyNotifyError

error-set

Source line 27

Errors

OutOfResources
Unexpected UnexpectedError

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.reset

function

Source line 31

Resets the input device hardware.

pub fn reset(self: *SimpleTextInputEx, verify: bool) ResetError!void

Parameters

self: *SimpleTextInputEx
verify: bool

Errors

DeviceError
Unexpected UnexpectedError

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.ResetError

error-set

Source line 17

Errors

DeviceError
Unexpected UnexpectedError

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.setState

function

Source line 52

Set certain state for the input device.

pub fn setState(self: *SimpleTextInputEx, state: *const Key.State.Toggle) SetStateError!void

Parameters

self: *SimpleTextInputEx
state: *const Key.State.Toggle

Errors

DeviceError
Unexpected UnexpectedError
Unsupported

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.SetStateError

error-set

Source line 23

Errors

DeviceError
Unexpected UnexpectedError
Unsupported

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.unregisterKeyNotify

function

Source line 76

Remove the notification that was previously registered.

pub fn unregisterKeyNotify( self: *SimpleTextInputEx, handle: uefi.Handle, ) UnregisterKeyNotifyError!void

Parameters

self: *SimpleTextInputEx
handle: uefi.Handle

Errors

InvalidParameter
Unexpected UnexpectedError

std.os.uefi.protocol.simple_text_input_ex.SimpleTextInputEx.UnregisterKeyNotifyError

error-set

Source line 28

Errors

InvalidParameter
Unexpected UnexpectedError

std.os.uefi.protocol.simple_text_input_ex.Status

alias

Source line 5

Alias of std.os.uefi.Status

std.os.uefi.protocol.simple_text_input_ex.std

alias

Source line 1

Alias of std

std.os.uefi.protocol.simple_text_input_ex.uefi

alias

Source line 2

Alias of std.os.uefi

Source code

std/os/uefi/protocol/simple_text_input_ex.zig

const std = @import("std");
const uefi = std.os.uefi;
const Event = uefi.Event;
const Guid = uefi.Guid;
const Status = uefi.Status;
const cc = uefi.cc;

/// Character input devices, e.g. Keyboard
pub const SimpleTextInputEx = extern struct {
    _reset: *const fn (*SimpleTextInputEx, bool) callconv(cc) Status,
    _read_key_stroke_ex: *const fn (*SimpleTextInputEx, *Key) callconv(cc) Status,
    wait_for_key_ex: Event,
    _set_state: *const fn (*SimpleTextInputEx, *const u8) callconv(cc) Status,
    _register_key_notify: *const fn (*SimpleTextInputEx, *const Key, *const fn (*const Key) callconv(cc) Status, **anyopaque) callconv(cc) Status,
    _unregister_key_notify: *const fn (*SimpleTextInputEx, *const anyopaque) callconv(cc) Status,

    pub const ResetError = uefi.UnexpectedError || error{DeviceError};
    pub const ReadKeyStrokeError = uefi.UnexpectedError || error{
        NotReady,
        DeviceError,
        Unsupported,
    };
    pub const SetStateError = uefi.UnexpectedError || error{
        DeviceError,
        Unsupported,
    };
    pub const RegisterKeyNotifyError = uefi.UnexpectedError || error{OutOfResources};
    pub const UnregisterKeyNotifyError = uefi.UnexpectedError || error{InvalidParameter};

    /// Resets the input device hardware.
    pub fn reset(self: *SimpleTextInputEx, verify: bool) ResetError!void {
        switch (self._reset(self, verify)) {
            .success => {},
            .device_error => return error.DeviceError,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    /// Reads the next keystroke from the input device.
    pub fn readKeyStroke(self: *SimpleTextInputEx) ReadKeyStrokeError!Key {
        var key: Key = undefined;
        switch (self._read_key_stroke_ex(self, &key)) {
            .success => return key,
            .not_ready => return error.NotReady,
            .device_error => return error.DeviceError,
            .unsupported => return error.Unsupported,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    /// Set certain state for the input device.
    pub fn setState(self: *SimpleTextInputEx, state: *const Key.State.Toggle) SetStateError!void {
        switch (self._set_state(self, @ptrCast(state))) {
            .success => {},
            .device_error => return error.DeviceError,
            .unsupported => return error.Unsupported,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    /// Register a notification function for a particular keystroke for the input device.
    pub fn registerKeyNotify(
        self: *SimpleTextInputEx,
        key_data: *const Key,
        notify: *const fn (*const Key) callconv(cc) Status,
    ) RegisterKeyNotifyError!uefi.Handle {
        var handle: uefi.Handle = undefined;
        switch (self._register_key_notify(self, key_data, notify, &handle)) {
            .success => return handle,
            .out_of_resources => return error.OutOfResources,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    /// Remove the notification that was previously registered.
    pub fn unregisterKeyNotify(
        self: *SimpleTextInputEx,
        handle: uefi.Handle,
    ) UnregisterKeyNotifyError!void {
        switch (self._unregister_key_notify(self, handle)) {
            .success => {},
            .invalid_parameter => return error.InvalidParameter,
            else => |status| return uefi.unexpectedStatus(status),
        }
    }

    pub const guid align(8) = Guid{
        .time_low = 0xdd9e7534,
        .time_mid = 0x7762,
        .time_high_and_version = 0x4698,
        .clock_seq_high_and_reserved = 0x8c,
        .clock_seq_low = 0x14,
        .node = [_]u8{ 0xf5, 0x85, 0x17, 0xa6, 0x25, 0xaa },
    };

    pub const Key = extern struct {
        input: Input,
        state: State,

        pub const State = extern struct {
            shift: Shift,
            toggle: Toggle,

            pub const Shift = packed struct(u32) {
                right_shift_pressed: bool,
                left_shift_pressed: bool,
                right_control_pressed: bool,
                left_control_pressed: bool,
                right_alt_pressed: bool,
                left_alt_pressed: bool,
                right_logo_pressed: bool,
                left_logo_pressed: bool,
                menu_key_pressed: bool,
                sys_req_pressed: bool,
                _pad: u21 = 0,
                shift_state_valid: bool,
            };

            pub const Toggle = packed struct(u8) {
                scroll_lock_active: bool,
                num_lock_active: bool,
                caps_lock_active: bool,
                _pad: u3 = 0,
                key_state_exposed: bool,
                toggle_state_valid: bool,
            };
        };

        pub const Input = extern struct {
            scan_code: u16,
            unicode_char: u16,
        };
    };
};