AccessKit

https://docs.rs/accesskit/latest
Admin
AccessKit is a Rust library that provides a cross-platform accessibility API for building accessible...
Tokens:53,947
Snippets:392
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Get UUID variant

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=u32+-%3E+bool

Retrieves the variant of the UUID structure.

```rust
let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?;

assert_eq!(Variant::RFC4122, my_uuid.get_variant());
```

--------------------------------

### Node Initialization and Action Management

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Core methods for creating a new node and managing actions or child actions on a node.

```rust
impl Node {
    #[inline]
    pub fn new(role: Role) -> Self {
        Self {
            role,
            ..Default::default()
        }
    }
}

impl Node {
    #[inline]
    pub fn role(&self) -> Role {
        self.role
    }
    #[inline]
    pub fn set_role(&mut self, value: Role) {
        self.role = value;
    }

    #[inline]
    pub fn supports_action(&self, action: Action) -> bool {
        (self.actions & action.mask()) != 0
    }
    #[inline]
    pub fn add_action(&mut self, action: Action) {
        self.actions |= action.mask();
    }
    #[inline]
    pub fn remove_action(&mut self, action: Action) {
        self.actions &= !(action.mask());
    }
    #[inline]
    pub fn clear_actions(&mut self) {
        self.actions = 0;
    }

    /// Return whether the specified action is in the set supported on this node's
    /// direct children in the filtered tree.
    #[inline]
    pub fn child_supports_action(&self, action: Action) -> bool {
        (self.child_actions & action.mask()) != 0
    }
    /// Add the specified action to the set supported on this node's direct
    /// children in the filtered tree.
    #[inline]
    pub fn add_child_action(&mut self, action: Action) {
        self.child_actions |= action.mask();
    }
    /// Remove the specified action from the set supported on this node's direct
    /// children in the filtered tree.
    #[inline]
    pub fn remove_child_action(&mut self, action: Action) {
        self.child_actions &= !(action.mask());
    }
    /// Clear the set of actions supported on this node's direct children in the
    /// filtered tree.
    #[inline]
    pub fn clear_child_actions(&mut self) {
        self.child_actions = 0;
    }
}
```

--------------------------------

### ActivationHandler::request_initial_tree

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=u32+-%3E+bool

Requests a TreeUpdate with a full tree to initialize the accessibility implementation. If the application can generate the tree synchronously, it should return it; otherwise, it must send the update asynchronously to the platform adapter.

```APIDOC
## ActivationHandler::request_initial_tree

### Description
Requests a `TreeUpdate` with a full tree. This method allows the application to lazily initialize its accessibility implementation.

### Usage
If the application can generate the tree synchronously, it should return the `TreeUpdate`. Otherwise, it must send the update to the platform adapter asynchronously, no later than the next display refresh.
```

--------------------------------

### Get UUID as u128

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the UUID packed into a 128-bit integer.

```rust
let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;

assert_eq!(
    uuid.as_u128(),
    0xa1a2a3a4b1b2c1c2d1d2d3d4d5d6d7d8,
);
```

--------------------------------

### Initialize a new Tree

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Use the new method to create a Tree instance with a specified root node ID.

```rust
impl Tree {
    #[inline]
    pub fn new(root: NodeId) -> Tree {
        Tree {
            root,
            toolkit_name: None,
            toolkit_version: None,
        }
    }
}
```

--------------------------------

### Get UUID version number

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=u32+-%3E+bool

Retrieves the version number of the UUID as a usize.

```rust
let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?;

assert_eq!(3, my_uuid.get_version_num());
```

--------------------------------

### ActivationHandler::request_initial_tree

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Requests a TreeUpdate containing the full accessibility tree. Applications should return the tree synchronously if possible, or send it asynchronously to the platform adapter.

```APIDOC
## ActivationHandler::request_initial_tree

### Description
Requests a `TreeUpdate` with a full tree. This method allows the application to lazily initialize its accessibility implementation. If the application can generate the tree synchronously, it should return the `TreeUpdate`. Otherwise, it must send the update to the platform adapter asynchronously no later than the next display refresh.

### Parameters
- **&self** - The instance of the activation handler.

### Returns
- **Option<TreeUpdate>** - The full accessibility tree if available synchronously, otherwise None.
```

--------------------------------

### Get UUID as Bytes

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns a reference to the 16-byte array underlying the UUID.

```rust
let bytes1 = [
    0xa1, 0xa2, 0xa3, 0xa4,
    0xb1, 0xb2,
    0xc1, 0xc2,
    0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8,
];
let uuid1 = Uuid::from_bytes_ref(&bytes1);

let bytes2 = uuid1.as_bytes();
let uuid2 = Uuid::from_bytes_ref(bytes2);

assert_eq!(uuid1, uuid2);

assert!(std::ptr::eq(
    uuid2 as *const Uuid as *const u8,
    &bytes1 as *const [u8; 16] as *const u8,
));
```

--------------------------------

### fn do_action(&mut self, request: ActionRequest)

Source: https://docs.rs/accesskit/latest/accesskit/trait.ActionHandler.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Performs the requested action. If the action is not supported, the implementation should do nothing. This method can be implemented to handle requests synchronously or asynchronously.

```APIDOC
## fn do_action(&mut self, request: ActionRequest)

### Description
Perform the requested action. If the requested action is not supported, this method must do nothing. This method may queue the request and handle it asynchronously, which is preferred over blocking.

### Parameters
- **request** (ActionRequest) - The action request to be processed by the handler.
```

--------------------------------

### Get UUID as 64-bit Pair

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the UUID split into two 64-bit integers.

```rust
let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;
assert_eq!(
    uuid.as_u64_pair(),
    (0xa1a2a3a4b1b2c1c2, 0xd1d2d3d4d5d6d7d8),
);
```

--------------------------------

### request_initial_tree

Source: https://docs.rs/accesskit/latest/accesskit/trait.ActivationHandler.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Requests a full TreeUpdate from the application. This method is used to lazily initialize the accessibility implementation and must return a full tree update.

```APIDOC
## fn request_initial_tree(&mut self) -> Option<TreeUpdate>

### Description
Requests a `TreeUpdate` with a full tree. If the application can generate the tree synchronously, it should do so; otherwise, it must send the update to the platform adapter asynchronously.

### Parameters
- **&mut self** - The mutable reference to the implementation of the trait.

### Returns
- **Option<TreeUpdate>** - Returns a full `TreeUpdate` if available synchronously, otherwise returns `None`.
```

--------------------------------

### Get UUID Version

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the version of the UUID, representing the algorithm used for generation.

```rust
let my_uuid = Uuid::parse_str("02f09a3f-1624-3b1d-8409-44eff7708208")?;

assert_eq!(Some(Version::Md5), my_uuid.get_version());
```

--------------------------------

### Node Property Macro Implementation

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=u32+-%3E+bool

Macro-generated methods for getting, setting, and clearing node properties.

```rust
match self.properties.indices.get(&self.properties.values, PropertyId::$id) {
                    PropertyValue::$id(value) => Some(*value),
                    _ => None,
                }
            }
            #[inline]
            pub fn $setter(&mut self, value: $id) {
                self.properties.set(PropertyId::$id, PropertyValue::$id(value));
            }
            #[inline]
            pub fn $clearer(&mut self) {
                self.properties.clear(PropertyId::$id);
            })*
            option_properties_debug_method! { debug_unique_enum_properties, [$($getter,)*] }
        }
        $(#[cfg(test)]
        mod $getter {
            use super::{Node, Role};

            #[test]
            fn getter_should_return_default_value() {
                let node = Node::new(Role::Unknown);
                assert!(node.$getter().is_none());
            }
            #[test]
            fn setter_should_update_the_property() {
                let mut node = Node::new(Role::Unknown);
                let variant = super::$id::$variant;
                node.$setter(variant);
                assert_eq!(node.$getter(), Some(variant));
            }
            #[test]
            fn clearer_should_reset_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter(super::$id::$variant);
                node.$clearer();
                assert!(node.$getter().is_none());
            }
        })*
```

--------------------------------

### Rect Methods

Source: https://docs.rs/accesskit/latest/src/accesskit/geometry.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Core methods for creating and querying Rect properties.

```rust
impl Rect {
    /// The empty rectangle at the origin.
    pub const ZERO: Rect = Rect::new(0., 0., 0., 0.);

    /// A new rectangle from minimum and maximum coordinates.
    #[inline]
    pub const fn new(x0: f64, y0: f64, x1: f64, y1: f64) -> Rect {
        Rect { x0, y0, x1, y1 }
    }

    /// A new rectangle from two points.
    ///
    /// The result will have non-negative width and height.
    #[inline]
    pub fn from_points(p0: impl Into<Point>, p1: impl Into<Point>) -> Rect {
        let p0 = p0.into();
        let p1 = p1.into();
        Rect::new(p0.x, p0.y, p1.x, p1.y).abs()
    }

    /// A new rectangle from origin and size.
    ///
    /// The result will have non-negative width and height.
    #[inline]
    pub fn from_origin_size(origin: impl Into<Point>, size: impl Into<Size>) -> Rect {
        let origin = origin.into();
        Rect::from_points(origin, origin + size.into().to_vec2())
    }

    /// Create a new `Rect` with the same size as `self` and a new origin.
    #[inline]
    pub fn with_origin(self, origin: impl Into<Point>) -> Rect {
        Rect::from_origin_size(origin, self.size())
    }

    /// Create a new `Rect` with the same origin as `self` and a new size.
    #[inline]
    pub fn with_size(self, size: impl Into<Size>) -> Rect {
        Rect::from_origin_size(self.origin(), size)
    }

    /// The width of the rectangle.
    ///
    /// Note: nothing forbids negative width.
    #[inline]
    pub fn width(&self) -> f64 {
        self.x1 - self.x0
    }

    /// The height of the rectangle.
    ///
    /// Note: nothing forbids negative height.
    #[inline]
    pub fn height(&self) -> f64 {
        self.y1 - self.y0
    }

    /// Returns the minimum value for the x-coordinate of the rectangle.
    #[inline]
    pub fn min_x(&self) -> f64 {
        self.x0.min(self.x1)
    }

    /// Returns the maximum value for the x-coordinate of the rectangle.
    #[inline]
    pub fn max_x(&self) -> f64 {
        self.x0.max(self.x1)
    }

    /// Returns the minimum value for the y-coordinate of the rectangle.
    #[inline]
    pub fn min_y(&self) -> f64 {
        self.y0.min(self.y1)
    }

    /// Returns the maximum value for the y-coordinate of the rectangle.
    #[inline]
    pub fn max_y(&self) -> f64 {
        self.y0.max(self.y1)
    }

    /// The origin of the rectangle.
    ///
    /// This is the top left corner in a y-down space and with
    /// non-negative width and height.
    #[inline]
    pub fn origin(&self) -> Point {
```

--------------------------------

### Action Support Verification

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Uses a macro to verify that new nodes do not support any actions by default.

```rust
macro_rules! assert_absent_action {
    ($node:ident, $action:ident) => {
        assert!(!$node.supports_action(Action::$action));
        assert!(!$node.child_supports_action(Action::$action));
    };
}

#[test]
fn new_node_should_not_support_anyaction() {
    let node = Node::new(Role::Unknown);
    assert_absent_action!(node, Click);
    assert_absent_action!(node, Focus);
    assert_absent_action!(node, Blur);
    assert_absent_action!(node, Collapse);
    assert_absent_action!(node, Expand);
    assert_absent_action!(node, CustomAction);
    assert_absent_action!(node, Decrement);
    assert_absent_action!(node, Increment);
    assert_absent_action!(node, HideTooltip);
    assert_absent_action!(node, ShowTooltip);
    assert_absent_action!(node, ReplaceSelectedText);
    assert_absent_action!(node, ScrollDown);
    assert_absent_action!(node, ScrollLeft);
    assert_absent_action!(node, ScrollRight);
    assert_absent_action!(node, ScrollUp);
    assert_absent_action!(node, ScrollIntoView);
    assert_absent_action!(node, ScrollToPoint);
    assert_absent_action!(node, SetScrollOffset);
    assert_absent_action!(node, SetTextSelection);
    assert_absent_action!(node, SetSequentialFocusNavigationStartingPoint);
    assert_absent_action!(node, SetValue);
    assert_absent_action!(node, ShowContextMenu);
}
```

--------------------------------

### Get UUID Fields

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the four field values of the UUID, which can be used to reconstruct the UUID.

```rust
let uuid = Uuid::nil();

assert_eq!(uuid.as_fields(), (0, 0, 0, &[0u8; 8]));

let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;

assert_eq!(
    uuid.as_fields(),
    (
        0xa1a2a3a4,
        0xb1b2,
        0xc1c2,
        &[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8],
    )
);
```

--------------------------------

### TextSelection Struct Definition

Source: https://docs.rs/accesskit/latest/accesskit/struct.TextSelection.html?search=std%3A%3Avec

The core structure defining the start and end points of a text selection.

```rust
pub struct TextSelection {
    pub anchor: TextPosition,
    pub focus: TextPosition,
}
```

--------------------------------

### Implement Action Methods

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=u32+-%3E+bool

Methods for generating a bitmask from an action and manually converting a numeric value to an Action variant.

```rust
impl Action {
    fn mask(self) -> u32 {
        1 << (self as u8)
    }

    #[cfg(not(feature = "enumn"))]
    fn n(value: u8) -> Option<Self> {
        // Manually implement something similar to the enumn crate. We don't
        // want to bring this crate by default though and we can't use a
        // macro as it would break C bindings header file generation.
        match value {
            0 => Some(Action::Click),
            1 => Some(Action::Focus),
            2 => Some(Action::Blur),
            3 => Some(Action::Collapse),
            4 => Some(Action::Expand),
```

--------------------------------

### Tree Initialization

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Validates that a new Tree is initialized with the correct root ID and default toolkit metadata.

```rust
    #[test]
    fn new_tree_should_have_root_id() {
        let tree = Tree::new(NodeId(1));
        assert_eq!(tree.root, NodeId(1));
        assert_eq!(tree.toolkit_name, None);
        assert_eq!(tree.toolkit_version, None);
    }
```

--------------------------------

### Get UUID as Little-Endian u128

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the UUID as a 128-bit integer with bytes flipped to little-endian order.

```rust
let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;

assert_eq!(
    uuid.to_u128_le(),
    0xd8d7d6d5d4d3d2d1c2c1b2b1a4a3a2a1,
);
```

--------------------------------

### Implement Property Storage Structures

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=u32+-%3E+bool

PropertyIndices and Properties manage the mapping and storage of property values for accessible nodes.

```rust
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(transparent)]
struct PropertyIndices([u8; PropertyId::Unset as usize]);

impl Default for PropertyIndices {
    fn default() -> Self {
        Self([PropertyId::Unset as u8; PropertyId::Unset as usize])
    }
}

#[derive(Clone, Debug, Default, PartialEq)]
struct Properties {
    indices: PropertyIndices,
    values: Vec<PropertyValue>,
}
```

--------------------------------

### Get UUID Fields in Little-Endian

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the four field values of the UUID converted to little-endian order.

```rust
use uuid::Uuid;

let uuid = Uuid::parse_str("a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8")?;

assert_eq!(
    uuid.to_fields_le(),
    (
        0xa4a3a2a1,
        0xb2b1,
        0xc2c1,
        &[0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8],
    )
);
```

--------------------------------

### fn do_action

Source: https://docs.rs/accesskit/latest/accesskit/trait.ActionHandler.html?search=std%3A%3Avec

Performs the requested action. If the action is not supported, the implementation should do nothing. This method may be called from platform-dependent threads and should ideally handle requests asynchronously.

```APIDOC
## fn do_action(&mut self, request: ActionRequest)

### Description
Perform the requested action. If the requested action is not supported, this method must do nothing.

### Parameters
- **request** (ActionRequest) - The action request to be processed.

### Notes
- The thread on which this method is called is platform-dependent.
- This method may queue the request and handle it asynchronously, which is preferred over blocking.
```

--------------------------------

### Construct and Manipulate Affine Transforms

Source: https://docs.rs/accesskit/latest/src/accesskit/geometry.rs.html?search=

Methods for creating affine transforms from coefficients, scaling, translation, and mapping unit squares.

```rust
    #[inline]
    pub const fn new(c: [f64; 6]) -> Affine {
        Affine(c)
    }

    /// An affine transform representing uniform scaling.
    #[inline]
    pub const fn scale(s: f64) -> Affine {
        Affine([s, 0.0, 0.0, s, 0.0, 0.0])
    }

    /// An affine transform representing non-uniform scaling
    /// with different scale values for x and y
    #[inline]
    pub const fn scale_non_uniform(s_x: f64, s_y: f64) -> Affine {
        Affine([s_x, 0.0, 0.0, s_y, 0.0, 0.0])
    }

    /// An affine transform representing translation.
    #[inline]
    pub fn translate<V: Into<Vec2>>(p: V) -> Affine {
        let p = p.into();
        Affine([1.0, 0.0, 0.0, 1.0, p.x, p.y])
    }

    /// Creates an affine transformation that takes the unit square to the given rectangle.
    ///
    /// Useful when you want to draw into the unit square but have your output fill any rectangle.
    /// In this case push the `Affine` onto the transform stack.
    pub fn map_unit_square(rect: Rect) -> Affine {
        Affine([rect.width(), 0., 0., rect.height(), rect.x0, rect.y0])
    }
```

--------------------------------

### color_property_methods Macro

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Generates property methods for Color values and includes unit tests for getter, setter, and clearer functionality.

```rust
macro_rules! color_property_methods {
    ($($(#[$doc:meta])* ($id:ident, $getter:ident, $setter:ident, $clearer:ident)),+) => {
        $(property_methods! {
            $(#[$doc])*
            ($id, $getter, get_color_property, Option<Color>, $setter, set_color_property, Color, $clearer)
        })*
        impl Node {
            option_properties_debug_method! { debug_color_properties, [$($getter,)*] }
        }
        $(#[cfg(test)]
        mod $getter {
            use super::{Color, Node, Role};

            #[test]
            fn getter_should_return_default_value() {
                let node = Node::new(Role::Unknown);
                assert!(node.$getter().is_none());
            }
            #[test]
            fn setter_should_update_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter(Color { red: 255, green: 255, blue: 255, alpha: 255 });
                assert_eq!(node.$getter(), Some(Color { red: 255, green: 255, blue: 255, alpha: 255 }));
            }
            #[test]
            fn clearer_should_reset_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter(Color { red: 255, green: 255, blue: 255, alpha: 255 });
                node.$clearer();
                assert!(node.$getter().is_none());
            }
        })*
    }
}
```

--------------------------------

### Uuid Creation Methods

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=u32+-%3E+bool

Methods for creating Uuid instances from various input types.

```APIDOC
## Uuid::nil()
Creates a 'nil UUID' (all zeros).

## Uuid::max()
Creates a 'max UUID' (all ones).

## Uuid::from_fields(d1: u32, d2: u16, d3: u16, d4: &[u8; 8])
Creates a UUID from four field values.

## Uuid::from_fields_le(d1: u32, d2: u16, d3: u16, d4: &[u8; 8])
Creates a UUID from four field values in little-endian order.

## Uuid::from_u128(v: u128)
Creates a UUID from a 128bit value.

## Uuid::from_u128_le(v: u128)
Creates a UUID from a 128bit value in little-endian order.

## Uuid::from_u64_pair(high_bits: u64, low_bits: u64)
Creates a UUID from two 64bit values.

## Uuid::from_slice(b: &[u8])
Creates a UUID using the supplied bytes. Returns an error if the slice length is not 16.

## Uuid::from_slice_le(b: &[u8])
Creates a UUID using the supplied bytes in little endian order. Returns an error if the slice length is not 16.

## Uuid::from_bytes(bytes: [u8; 16])
Creates a UUID using the supplied 16-byte array.
```

--------------------------------

### Size Methods

Source: https://docs.rs/accesskit/latest/src/accesskit/geometry.rs.html?search=u32+-%3E+bool

Methods available on the Size structure for 2D dimension management.

```APIDOC
## Size::new(width: f64, height: f64)

### Description
Creates a new Size instance with the specified width and height.

## Size::to_vec2()

### Description
Converts the size into a Vec2, mapping width to x and height to y.
```

--------------------------------

### usize_property_methods Macro

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Generates property methods for usize values and includes unit tests for getter, setter, and clearer functionality.

```rust
macro_rules! usize_property_methods {
    ($($(#[$doc:meta])* ($id:ident, $getter:ident, $setter:ident, $clearer:ident)),+) => {
        $(property_methods! {
            $(#[$doc])*
            ($id, $getter, get_usize_property, Option<usize>, $setter, set_usize_property, usize, $clearer)
        })*
        impl Node {
            option_properties_debug_method! { debug_usize_properties, [$($getter,)*] }
        }
        $(#[cfg(test)]
        mod $getter {
            use super::{Node, Role};

            #[test]
            fn getter_should_return_default_value() {
                let node = Node::new(Role::Unknown);
                assert!(node.$getter().is_none());
            }
            #[test]
            fn setter_should_update_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter(1);
                assert_eq!(node.$getter(), Some(1));
            }
            #[test]
            fn clearer_should_reset_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter(1);
                node.$clearer();
                assert!(node.$getter().is_none());
            }
        })*
    }
}
```

--------------------------------

### Affine Transformation Methods

Source: https://docs.rs/accesskit/latest/src/accesskit/geometry.rs.html?search=

Methods for checking finiteness and NaN status of an Affine transformation matrix.

```rust
pub fn is_finite(&self) -> bool {
        self.0[0].is_finite()
            && self.0[1].is_finite()
            && self.0[2].is_finite()
            && self.0[3].is_finite()
            && self.0[4].is_finite()
            && self.0[5].is_finite()
    }

    /// Is this map NaN?
    #[inline]
    pub fn is_nan(&self) -> bool {
        self.0[0].is_nan()
            || self.0[1].is_nan()
            || self.0[2].is_nan()
            || self.0[3].is_nan()
            || self.0[4].is_nan()
            || self.0[5].is_nan()
    }
```

--------------------------------

### Property Management Methods

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Methods for retrieving, setting, and clearing properties within a collection.

```rust
fn get_mut(&mut self, id: PropertyId, default: PropertyValue) -> &mut PropertyValue {
        let index = self.indices.0[id as usize] as usize;
        if index == PropertyId::Unset as usize {
            self.values.push(default);
            let index = self.values.len() - 1;
            self.indices.0[id as usize] = index as u8;
            &mut self.values[index]
        } else {
            &mut self.values[index]
        }
    }

    fn set(&mut self, id: PropertyId, value: PropertyValue) {
        let index = self.indices.0[id as usize];
        if index == PropertyId::Unset as u8 {
            self.values.push(value);
            self.indices.0[id as usize] = (self.values.len() - 1) as u8;
        } else {
            self.values[index as usize] = value;
        }
    }

    fn clear(&mut self, id: PropertyId) {
        let index = self.indices.0[id as usize];
        if index != PropertyId::Unset as u8 {
            self.values[index as usize] = PropertyValue::None;
        }
    }
}
```

--------------------------------

### Flag Methods Macro

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Macro to generate getter, setter, and clearer methods for node flags, including unit tests.

```rust
macro_rules! flag_methods {
    ($($(#[$doc:meta])* ($id:ident, $getter:ident, $setter:ident, $clearer:ident)),+) => {
        impl Node {
            $($(#[$doc])*
            #[inline]
            pub fn $getter(&self) -> bool {
                (self.flags & (Flag::$id).mask()) != 0
            }
            #[inline]
            pub fn $setter(&mut self) {
                self.flags |= (Flag::$id).mask();
            }
            #[inline]
            pub fn $clearer(&mut self) {
                self.flags &= !((Flag::$id).mask());
            })*
            fn debug_flag_properties(&self, fmt: &mut fmt::DebugStruct) {
                $(
                    if self.$getter() {
                        fmt.field(stringify!($getter), &true);
                    }
                )*
            }
        }
        $(#[cfg(test)]
        mod $getter {
            use super::{Node, Role};

            #[test]
            fn getter_should_return_default_value() {
                let node = Node::new(Role::Unknown);
                assert!(!node.$getter());
            }

            #[test]
            fn setter_should_update_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter();
                assert!(node.$getter());
            }

            #[test]
            fn clearer_should_reset_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter();
                node.$clearer();
                assert!(!node.$getter());
            }
        })*
    }
}
```

--------------------------------

### Size Structure Definition and Methods

Source: https://docs.rs/accesskit/latest/src/accesskit/geometry.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Definition of the Size struct and basic conversion methods.

```rust
pub struct Size {
    pub width: f64,
    pub height: f64,
}

impl Size {
    pub const ZERO: Size = Size::new(0., 0.);

    pub const fn new(width: f64, height: f64) -> Self {
        Size { width, height }
    }

    pub const fn to_vec2(self) -> Vec2 {
        Vec2::new(self.width, self.height)
    }
}
```

--------------------------------

### Size Arithmetic and Conversion Implementations

Source: https://docs.rs/accesskit/latest/src/accesskit/geometry.rs.html?search=u32+-%3E+bool

Implementations for Size arithmetic operations and tuple conversions.

```rust
type Output = Size;
    #[inline]
    fn add(self, other: Size) -> Size {
        Size {
            width: self.width + other.width,
            height: self.height + other.height,
        }
    }
}

impl AddAssign<Size> for Size {
    #[inline]
    fn add_assign(&mut self, other: Size) {
        *self = *self + other;
    }
}

impl Sub<Size> for Size {
    type Output = Size;
    #[inline]
    fn sub(self, other: Size) -> Size {
        Size {
            width: self.width - other.width,
            height: self.height - other.height,
        }
    }
}

impl SubAssign<Size> for Size {
    #[inline]
    fn sub_assign(&mut self, other: Size) {
        *self = *self - other;
    }
}

impl From<(f64, f64)> for Size {
    #[inline]
    fn from(v: (f64, f64)) -> Size {
        Size {
            width: v.0,
            height: v.1,
        }
    }
}

impl From<Size> for (f64, f64) {
    #[inline]
    fn from(v: Size) -> (f64, f64) {
        (v.width, v.height)
    }
}
```

--------------------------------

### text_decoration_property_methods Macro

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Generates property methods for TextDecoration values and includes unit tests for getter, setter, and clearer functionality.

```rust
macro_rules! text_decoration_property_methods {
    ($($(#[$doc:meta])* ($id:ident, $getter:ident, $setter:ident, $clearer:ident)),+) => {
        $(property_methods! {
            $(#[$doc])*
            ($id, $getter, get_text_decoration_property, Option<TextDecoration>, $setter, set_text_decoration_property, TextDecoration, $clearer)
        })*
        impl Node {
            option_properties_debug_method! { debug_text_decoration_properties, [$($getter,)*] }
        }
        $(#[cfg(test)]
        mod $getter {
            use super::{Color, Node, Role, TextDecoration, TextDecorationStyle};

            const TEST_TEXT_DECORATION: TextDecoration = TextDecoration {
                style: TextDecorationStyle::Dotted,
                color: Color {
                    red: 0,
                    green: 0,
                    blue: 0,
                    alpha: 255,
                },
            };

            #[test]
            fn getter_should_return_default_value() {
                let node = Node::new(Role::Unknown);
                assert!(node.$getter().is_none());
            }
            #[test]
            fn setter_should_update_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter(TEST_TEXT_DECORATION);
                assert_eq!(node.$getter(), Some(TEST_TEXT_DECORATION));
            }
            #[test]
            fn clearer_should_reset_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter(TEST_TEXT_DECORATION);
                node.$clearer();
                assert!(node.$getter().is_none());
            }
        })*
    }
}
```

--------------------------------

### Define Debug Methods for Properties

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Macros to generate debug formatting logic for slice and option-based properties.

```rust
macro_rules! slice_properties_debug_method {
    ($name:ident, [$($getter:ident,)*]) => {
        fn $name(&self, fmt: &mut fmt::DebugStruct) {
            $(
                let value = self.$getter();
                if !value.is_empty() {
                    fmt.field(stringify!($getter), &value);
                }
            )*
        }
    }
}
```

```rust
macro_rules! option_properties_debug_method {
    ($name:ident, [$($getter:ident,)*]) => {
        fn $name(&self, fmt: &mut fmt::DebugStruct) {
            $(
                if let Some(value) = self.$getter() {
                    fmt.field(stringify!($getter), &value);
                }
            )*
        }
    }
}
```

--------------------------------

### f64 Property Macro

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Generates property methods for f64 floating-point properties.

```rust
macro_rules! f64_property_methods {
    ($($(#[$doc:meta])* ($id:ident, $getter:ident, $setter:ident, $clearer:ident)),+) => {
        $(property_methods! {
            $(#[$doc])*
            ($id, $getter, get_f64_property, Option<f64>, $setter, set_f64_property, f64, $clearer)
        })*
        impl Node {
            option_properties_debug_method! { debug_f64_properties, [$($getter,)*] }
        }
        $(#[cfg(test)]
        mod $getter {
            use super::{Node, Role};

            #[test]
            fn getter_should_return_default_value() {
                let node = Node::new(Role::Unknown);
                assert!(node.$getter().is_none());
            }
            #[test]
            fn setter_should_update_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter(1.0);
                assert_eq!(node.$getter(), Some(1.0));
            }
            #[test]
            fn clearer_should_reset_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter(1.0);
                node.$clearer();
                assert!(node.$getter().is_none());
            }
        })*
    }
}
```

--------------------------------

### Vec2 Methods

Source: https://docs.rs/accesskit/latest/src/accesskit/geometry.rs.html?search=std%3A%3Avec

Core methods for the Vec2 structure, including conversions to Point and Size.

```rust
impl Vec2 {
    /// The vector (0, 0).
    pub const ZERO: Vec2 = Vec2::new(0., 0.);

    /// Create a new vector.
    #[inline]
    pub const fn new(x: f64, y: f64) -> Vec2 {
        Vec2 { x, y }
    }

    /// Convert this vector into a `Point`.
    #[inline]
    pub const fn to_point(self) -> Point {
        Point::new(self.x, self.y)
    }

    /// Convert this vector into a `Size`.
    #[inline]
    pub const fn to_size(self) -> Size {
        Size::new(self.x, self.y)
    }
}
```

--------------------------------

### Uuid Creation and Parsing

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=u32+-%3E+bool

Methods for creating Uuid instances from bytes or strings.

```APIDOC
## Uuid::from_bytes_le(b: [u8; 16]) -> Uuid
Creates a UUID using the supplied bytes in little endian order.

## Uuid::from_bytes_ref(bytes: &[u8; 16]) -> &Uuid
Creates a reference to a UUID from a reference to the supplied bytes.

## Uuid::parse_str(input: &str) -> Result<Uuid, Error>
Parses a Uuid from a string of hexadecimal digits with optional hyphens.

## Uuid::try_parse(input: &str) -> Result<Uuid, Error>
Parses a Uuid from a string of hexadecimal digits with optional hyphens, providing minimal error diagnostics.

## Uuid::try_parse_ascii(input: &[u8]) -> Result<Uuid, Error>
Parses a Uuid from a byte slice of ASCII characters.
```

--------------------------------

### ActionHandler::do_action

Source: https://docs.rs/accesskit/latest/accesskit/trait.ActionHandler.html?search=u32+-%3E+bool

Performs the requested action. If the action is not supported, the method should do nothing. This method may be called from various threads depending on the platform adapter.

```APIDOC
## fn do_action(&mut self, request: ActionRequest)

### Description
Perform the requested action. If the requested action is not supported, this method must do nothing. This method may queue the request and handle it asynchronously, which is preferred over blocking.

### Parameters
- **request** (ActionRequest) - The action request to be performed.
```

--------------------------------

### Define Node and Property Storage Structures

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Structures for managing property indices and the primary Node representation.

```rust
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
#[repr(transparent)]
struct PropertyIndices([u8; PropertyId::Unset as usize]);

impl Default for PropertyIndices {
    fn default() -> Self {
        Self([PropertyId::Unset as u8; PropertyId::Unset as usize])
    }
}

#[derive(Clone, Debug, Default, PartialEq)]
struct Properties {
    indices: PropertyIndices,
    values: Vec<PropertyValue>,
}
```

```rust
#[derive(Clone, Default, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
#[cfg_attr(feature = "schemars", derive(JsonSchema))]
#[cfg_attr(feature = "serde", serde(deny_unknown_fields))]
#[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
pub struct Node {
    role: Role,
    actions: u32,
    child_actions: u32,
    flags: u32,
    properties: Properties,
}
```

--------------------------------

### Define Vector Property Methods

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Macros for generating getters, setters, and pushers for vector-based properties on a Node.

```rust
macro_rules! vec_type_methods {
    ($(($type:ty, $variant:ident, $getter:ident, $setter:ident, $pusher:ident)),+) => {
        $(slice_type_getters! {
            ($getter, $type, $variant)
        })*
        impl Node {
            $(fn $setter(&mut self, id: PropertyId, value: impl Into<Vec<$type>>) {
                self.properties.set(id, PropertyValue::$variant(value.into()));
            }
            fn $pusher(&mut self, id: PropertyId, item: $type) {
                if let PropertyValue::$variant(v) = self.properties.get_mut(id, PropertyValue::$variant(Vec::new())) {
                    v.push(item);
                }
            })*
        }
    }
}
```

```rust
macro_rules! vec_property_methods {
    ($($(#[$doc:meta])* ($id:ident, $item_type:ty, $getter:ident, $type_getter:ident, $setter:ident, $type_setter:ident, $pusher:ident, $type_pusher:ident, $clearer:ident)),+) => {
        $(property_methods! {
            $(#[$doc])*
            ($id, $getter, $type_getter, &[$item_type], $setter, $type_setter, impl Into<Vec<$item_type>>, $clearer)
        }
        impl Node {
            #[inline]
            pub fn $pusher(&mut self, item: $item_type) {
                self.$type_pusher(PropertyId::$id, item);
            }
        })*
    }
}
```

--------------------------------

### as_u64_pair

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=u32+-%3E+bool

Returns two 64bit values containing the value.

```APIDOC
## pub const fn as_u64_pair(&self) -> (u64, u64)

### Description
Returns two 64bit values containing the value. The bytes in the UUID will be split into two u64. The first u64 represents the 64 most significant bits, the second one represents the 64 least significant.
```

--------------------------------

### Affine Transformation API

Source: https://docs.rs/accesskit/latest/src/accesskit/geometry.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Methods for creating and manipulating 2D affine transformations.

```APIDOC
## Affine Struct

### Description
Represents a 2D affine transform using a 6-element array of f64 coefficients.

### Methods
- **new(c: [f64; 6]) -> Affine**: Construct an affine transform from coefficients.
- **scale(s: f64) -> Affine**: Create a uniform scaling transform.
- **scale_non_uniform(s_x: f64, s_y: f64) -> Affine**: Create a non-uniform scaling transform.
- **translate<V: Into<Vec2>>(p: V) -> Affine**: Create a translation transform.
- **map_unit_square(rect: Rect) -> Affine**: Create a transform that maps the unit square to a target rectangle.
- **determinant(self) -> f64**: Compute the determinant of the transform.
- **inverse(self) -> Affine**: Compute the inverse of the transform.
- **transform_rect_bbox(self, rect: Rect) -> Rect**: Compute the bounding box of a transformed rectangle.
```

--------------------------------

### Create a UUID from fields

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Constructs a UUID from four distinct field values.

```rust
let d1 = 0xa1a2a3a4;
let d2 = 0xb1b2;
let d3 = 0xc1c2;
let d4 = [0xd1, 0xd2, 0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8];

let uuid = Uuid::from_fields(d1, d2, d3, &d4);

assert_eq!(
    "a1a2a3a4-b1b2-c1c2-d1d2-d3d4d5d6d7d8",
    uuid.hyphenated().to_string(),
);
```

--------------------------------

### f32 Property Macro

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=std%3A%3Avec

Generates property methods for f32 floating-point properties.

```rust
macro_rules! f32_property_methods {
    ($($(#[$doc:meta])* ($id:ident, $getter:ident, $setter:ident, $clearer:ident)),+) => {
        $(property_methods! {
            $(#[$doc])*
            ($id, $getter, get_f32_property, Option<f32>, $setter, set_f32_property, f32, $clearer)
        })*
        impl Node {
            option_properties_debug_method! { debug_f32_properties, [$($getter,)*] }
        }
        $(#[cfg(test)]
        mod $getter {
            use super::{Node, Role};

            #[test]
            fn getter_should_return_default_value() {
                let node = Node::new(Role::Unknown);
                assert!(node.$getter().is_none());
            }
            #[test]
            fn setter_should_update_the_property() {
                let mut node = Node::new(Role::Unknown);
                node.$setter(1.0);
            }
        })*
    }
}
```

--------------------------------

### Uuid Constructors

Source: https://docs.rs/accesskit/latest/accesskit/struct.Uuid.html?search=std%3A%3Avec

Methods for creating Uuid instances from various data types and byte orders.

```APIDOC
## Uuid::nil()
Creates a nil UUID (all 128 bits set to zero).

## Uuid::max()
Creates a max UUID (all 128 bits set to one).

## Uuid::from_fields(d1: u32, d2: u16, d3: u16, d4: &[u8; 8])
Creates a UUID from four field values.

## Uuid::from_fields_le(d1: u32, d2: u16, d3: u16, d4: &[u8; 8])
Creates a UUID from four field values in little-endian order.

## Uuid::from_u128(v: u128)
Creates a UUID from a 128-bit integer.

## Uuid::from_u128_le(v: u128)
Creates a UUID from a 128-bit integer in little-endian order.

## Uuid::from_u64_pair(high_bits: u64, low_bits: u64)
Creates a UUID from two 64-bit integers.

## Uuid::from_slice(b: &[u8])
Creates a UUID from a byte slice. Returns an error if the slice length is not 16.

## Uuid::from_slice_le(b: &[u8])
Creates a UUID from a byte slice in little-endian order. Returns an error if the slice length is not 16.

## Uuid::from_bytes(bytes: [u8; 16])
Creates a UUID from a fixed-size array of 16 bytes.
```

--------------------------------

### f32 Property Macros

Source: https://docs.rs/accesskit/latest/src/accesskit/lib.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Generates property methods for f32-based properties and includes unit tests for getter and setter functionality.

```rust
macro_rules! f32_property_methods {
    ($($(#[$doc:meta])* ($id:ident, $getter:ident, $setter:ident, $clearer:ident)),+) => {
        $(property_methods! {
            $(#[$doc])*
            ($id, $getter, get_f32_property, Option<f32>, $setter, set_f32_property, f32, $clearer)
        })*
        impl Node {
            option_properties_debug_method! { debug_f32_properties, [$($getter,)*] }
        }
        $(#[cfg(test)]
        mod $getter {
            use super::{Node, Role};

            #[test]
            fn getter_should_return_default_value() {
                let node = Node::new(Role::Unknown);
                assert!(node.$getter().is_none());
            }
            #[test]
            fn setter_should_update_the_property() {
                let mut node = Node::new(Role::Unknown);
```
Tokens:
Raw