Struct HidUsage 

pub struct HidUsage { /* private fields */ }

Decoded ZMK HID usage values used in typed behavior APIs. Lossless decoded ZMK HID usage value (base usage + modifiers).

Implementations

impl HidUsage

pub fn from_encoded(encoded: u32) -> Self

Decode from ZMK’s encoded usage format.

ZMK encodes as:

• bits 31:24: modifiers
• bits 23:16: usage page
• bits 15:00: usage id

If page is 0, ZMK treats it as keyboard page (0x07).

Examples found in repository

examples/basic_example.rs (line 111)

fn run_example<T: Read + Write>(mut client: StudioClient<T>) -> Result<(), Box<dyn Error>> {
    let info = client.get_device_info()?;
    println!("Device: {}", info.name);
    println!("Lock: {:?}", client.get_lock_state()?);

    let behavior_ids = client.list_all_behaviors()?;
    println!("Behavior count: {}", behavior_ids.len());
    if let Some(first_behavior_id) = behavior_ids.first().copied() {
        let details = client.get_behavior_details(first_behavior_id)?;
        println!("First behavior: {} ({})", details.id, details.display_name);
    }

    let keymap = match client.get_keymap() {
        Ok(keymap) => keymap,
        Err(ClientError::Meta(_)) => {
            println!("Keymap request denied (likely locked); press `&studio_unlock` then rerun.");
            return Ok(());
        }
        Err(err) => return Err(Box::new(err)),
    };
    println!("Layers: {}", keymap.layers.len());

    let layouts = client.get_physical_layouts()?;
    println!(
        "Physical layouts: {} (active index: {})",
        layouts.layouts.len(),
        layouts.active_layout_index
    );

    let Some(first_layer) = keymap.layers.first() else {
        return Ok(());
    };
    if first_layer.bindings.is_empty() {
        return Ok(());
    }

    let layer_id = first_layer.id;
    let key_position = 0;

    let before = client.get_key_at(layer_id, key_position)?;
    println!("Before: {before:?}");

    client.set_key_at(
        layer_id,
        key_position,
        Behavior::KeyPress(HidUsage::from_encoded(Keycode::A.to_hid_usage())),
    )?;
    let after = client.get_key_at(layer_id, key_position)?;
    println!("After:  {after:?}");

    // Change management APIs.
    let has_changes = client.check_unsaved_changes()?;
    println!("Unsaved changes: {has_changes}");
    if has_changes {
        client.discard_changes()?;
    }

    Ok(())
}

pub fn from_parts(page: u16, id: u16, modifiers: u8) -> Self

pub fn to_hid_usage(self) -> u32

pub fn page(self) -> u16

pub fn id(self) -> u16

pub fn modifiers(self) -> u8

pub fn base(self) -> Self

pub fn known_keycode(self) -> Option<Keycode>

pub fn known_base_keycode(self) -> Option<Keycode>

pub fn modifier_labels(self) -> Vec<&'static str>

Trait Implementations

impl Clone for HidUsage

fn clone(&self) -> HidUsage

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for HidUsage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for HidUsage

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for HidUsage

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for HidUsage

fn eq(&self, other: &HidUsage) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for HidUsage

impl Eq for HidUsage

impl StructuralPartialEq for HidUsage