API v0.2.0

struct HidpiAdjustedBounds

logical_size: LogicalSize

hidpi_factor: DpiScaleFactor

• constructor from_bounds:

  • arg bounds: LayoutSize

  • arg hidpi_factor: DpiScaleFactor

  • -> HidpiAdjustedBounds

• fn get_physical_size:

  • &self

  • -> PhysicalSizeU32

• fn get_logical_size:

  • &self

  • -> LogicalSize

• fn get_hidpi_factor:

  • &self

  • -> DpiScaleFactor

struct DpiScaleFactor

inner: FloatValue

struct LinuxWindowOptions has destructor

wayland_theme: OptionWaylandTheme

window_icon: OptionWindowIcon

x11_gtk_theme_variant: OptionString

wayland_app_id: OptionString

x11_wm_classes: StringPairVec

x11_window_types: XWindowTypeVec

x11_visual: OptionX11Visual

x11_resize_increments: OptionLogicalSize

x11_base_size: OptionLogicalSize

x11_screen: OptionI32

request_user_attention: UserAttentionType

x11_decorations_state: OptionLinuxDecorationsState

x11_override_redirect: bool

struct WaylandTheme has destructor

title_bar_active_background_color: ColorU

title_bar_active_separator_color: ColorU

title_bar_active_text_color: ColorU

title_bar_inactive_background_color: ColorU

title_bar_inactive_separator_color: ColorU

title_bar_inactive_text_color: ColorU

maximize_idle_foreground_inactive_color: ColorU

minimize_idle_foreground_inactive_color: ColorU

close_idle_foreground_inactive_color: ColorU

maximize_hovered_foreground_inactive_color: ColorU

minimize_hovered_foreground_inactive_color: ColorU

close_hovered_foreground_inactive_color: ColorU

maximize_disabled_foreground_inactive_color: ColorU

minimize_disabled_foreground_inactive_color: ColorU

close_disabled_foreground_inactive_color: ColorU

maximize_idle_background_inactive_color: ColorU

minimize_idle_background_inactive_color: ColorU

close_idle_background_inactive_color: ColorU

maximize_hovered_background_inactive_color: ColorU

minimize_hovered_background_inactive_color: ColorU

close_hovered_background_inactive_color: ColorU

maximize_disabled_background_inactive_color: ColorU

minimize_disabled_background_inactive_color: ColorU

close_disabled_background_inactive_color: ColorU

maximize_idle_foreground_active_color: ColorU

minimize_idle_foreground_active_color: ColorU

close_idle_foreground_active_color: ColorU

maximize_hovered_foreground_active_color: ColorU

minimize_hovered_foreground_active_color: ColorU

close_hovered_foreground_active_color: ColorU

maximize_disabled_foreground_active_color: ColorU

minimize_disabled_foreground_active_color: ColorU

close_disabled_foreground_active_color: ColorU

maximize_idle_background_active_color: ColorU

minimize_idle_background_active_color: ColorU

close_idle_background_active_color: ColorU

maximize_hovered_background_active_color: ColorU

minimize_hovered_background_active_color: ColorU

close_hovered_background_active_color: ColorU

maximize_disabled_background_active_color: ColorU

minimize_disabled_background_active_color: ColorU

close_disabled_background_active_color: ColorU

title_bar_font: String

title_bar_font_size: f32

struct MonitorId

index: usize

hash: u64

struct WindowFlags

frame: WindowFrame

decorations: WindowDecorations

background_material: WindowBackgroundMaterial

window_type: WindowType

close_requested: bool

is_visible: bool

is_always_on_top: bool

is_resizable: bool

has_focus: bool

smooth_scroll_enabled: bool

autotab_enabled: bool

has_decorations: bool

use_native_menus: bool

use_native_context_menus: bool

is_top_level: bool

prevent_system_sleep: bool

fullscreen_mode: FullScreenMode

struct TaskBarIcon has destructor

key: IconKey

rgba_bytes: U8Vec

struct WasmWindowOptions

_reserved: u8

struct SmallWindowIconBytes has destructor

key: IconKey

rgba_bytes: U8Vec

struct Monitor has destructor

monitor_id: MonitorId

monitor_name: OptionString

size: LayoutSize

position: LayoutPoint

scale_factor: f64

work_area: LayoutRect

video_modes: VideoModeVec

is_primary_monitor: bool

struct IconKey

icon_id: usize

struct MacWindowOptions

_reserved: u8

struct VideoMode

size: LayoutSize

bit_depth: u16

refresh_rate: u16

struct LargeWindowIconBytes has destructor

key: IconKey

rgba_bytes: U8Vec

struct PlatformSpecificOptions has destructor

windows_options: WindowsWindowOptions

linux_options: LinuxWindowOptions

mac_options: MacWindowOptions

wasm_options: WasmWindowOptions

struct WindowSize

dimensions: LogicalSize

dpi: u32

min_dimensions: OptionLogicalSize

max_dimensions: OptionLogicalSize

struct WindowsWindowOptions has destructor

allow_drag_and_drop: bool

no_redirection_bitmap: bool

window_icon: OptionWindowIcon

taskbar_icon: OptionTaskBarIcon

struct WindowCreateOptions has destructor

window_state: FullWindowState

create_callback: OptionCallback

renderer: OptionRendererOptions

theme: OptionWindowTheme

size_to_content: bool

hot_reload: bool

parent_window_id: u64

Create a new WindowCreateOptions with a layout callback

• constructor create:

  • arg layout_callback: LayoutCallbackType

  • -> WindowCreateOptions

struct FullWindowState has destructor

platform_specific_options: PlatformSpecificOptions

keyboard_state: KeyboardState

window_id: String

title: String

close_callback: OptionCallback

layout_callback: LayoutCallback

position: WindowPosition

touch_state: TouchState

size: WindowSize

flags: WindowFlags

mouse_state: MouseState

theme: WindowTheme

ime_position: ImePosition

renderer_options: RendererOptions

monitor_id: OptionU32

debug_state: DebugState

background_color: OptionColorU

window_focused: bool

active_route: OptionRouteMatch

struct IOSHandle

ui_window: c_void

ui_view: c_void

ui_view_controller: c_void

struct MacOSHandle

ns_window: c_void

ns_view: c_void

struct XcbHandle

window: u32

connection: c_void

struct TextCursor

cluster_id: GraphemeClusterId

affinity: CursorAffinity

struct XlibHandle

window: u64

display: c_void

struct WaylandHandle

surface: c_void

display: c_void

struct WindowsHandle

hwnd: c_void

hinstance: c_void

struct WebHandle

id: u32

struct AndroidHandle

a_native_window: c_void

struct TextOpMoveCursor

old_position: CursorPosition

new_position: CursorPosition

movement: CursorMovement

struct IconProviderHandle

inner: c_void

run_destructor: bool

Create a new empty icon provider with the default resolver

• constructor create:

  • -> IconProviderHandle

Create with a custom resolver callback

• constructor with_resolver:

  • arg resolver: IconResolverCallbackType

  • -> IconProviderHandle

Set the resolver callback

• fn set_resolver:

  • &mut self

  • arg resolver: IconResolverCallbackType

Register a single icon in a pack (creates pack if needed)

• fn register_icon:

  • &mut self

  • arg pack_name: String

  • arg icon_name: String

  • arg data: RefAny

Unregister a single icon from a pack

• fn unregister_icon:

  • &mut self

  • arg pack_name: String

  • arg icon_name: String

Unregister an entire icon pack

• fn unregister_pack:

  • &mut self

  • arg pack_name: String

Look up an icon across all packs (first match wins)

• fn lookup:

  • &self

  • arg icon_name: String

  • -> OptionRefAny

Check if an icon exists in any pack

• fn has_icon:

  • &self

  • arg icon_name: String

  • -> bool

Register an image icon in a pack

• fn register_image_icon:

  • &mut self

  • arg pack_name: String

  • arg icon_name: String

  • arg image: ImageRef

Register a font icon in a pack

• fn register_font_icon:

  • &mut self

  • arg pack_name: String

  • arg icon_name: String

  • arg font: FontRef

  • arg icon_char: String

Debug lookup: returns detailed info about an icon's RefAny contents. Useful for debugging to verify icons are registered correctly.

• fn debug_lookup:

  • &self

  • arg icon_name: String

  • -> String

struct MimeTypeHint has destructor

inner: String

struct VideoModeVecSlice

Pointer to the slice data

ptr: VideoMode

Number of elements in the slice

len: usize

struct MonitorVecSlice has destructor

ptr: Monitor

len: usize

struct XWindowTypeVecSlice

Pointer to the slice data

ptr: XWindowType

Number of elements in the slice

len: usize

FFI-safe (mime_type, data) pair used to build a MimeTypeDataVec for DragData.

struct MimeTypeData has destructor

mime_type: String

data: U8Vec

struct MimeTypeDataVecSlice has destructor

Pointer to the slice data

ptr: MimeTypeData

Number of elements in the slice

len: usize

Single touch point (finger, stylus, etc.)

struct TouchPoint

Unique identifier for this touch point (persists across move events)

id: u64

Current position of the touch point in logical coordinates

position: LogicalPosition

Force / pressure of the touch (0.0 = none, 1.0 = max). Set to 0.5 if pressure is unavailable.

force: f32

struct TouchPointVecSlice

Pointer to the slice data

ptr: TouchPoint

Number of elements in the slice

len: usize

Result of pinch gesture detection (scale + center + travel distances + duration).

struct DetectedPinch

Scale factor (< 1.0 for pinch in, > 1.0 for pinch out)

scale: f32

Center point of the pinch gesture

center: LogicalPosition

Distance between touch points when the pinch started, in logical px

initial_distance: f32

Current distance between touch points, in logical px

current_distance: f32

Duration of the pinch so far, in milliseconds

duration_ms: u64

struct PlatformCapability has destructor

available: bool

backend: String

reason: String

Probe camera capture availability + backend (non-destructive).

• constructor camera:

  • -> PlatformCapability

Probe screen-capture availability + backend (portal+PipeWire on Linux, ScreenCaptureKit on macOS 12.3+).

• constructor screen_capture:

  • -> PlatformCapability

Probe microphone capture availability + backend.

• constructor microphone:

  • -> PlatformCapability

Probe audio output (AudioSink) availability + backend.

• constructor audio_output:

  • -> PlatformCapability

Probe motion-sensor availability + backend (false on a device with no sensor, never panics).

• constructor sensors:

  • -> PlatformCapability

Probe gamepad backend (does not initialise gilrs; a pad is detected on poll).

• constructor gamepad:

  • -> PlatformCapability

Probe geolocation availability + backend (currently a stub on all platforms).

• constructor geolocation:

  • -> PlatformCapability

Probe the OS secret keyring backend.

• constructor keyring:

  • -> PlatformCapability

Probe biometric auth (uses the real sync availability check - reflects device/enrolment state).

• constructor biometric:

  • -> PlatformCapability

Probe the hardware video codec (currently a stub on all platforms).

• constructor video_codec:

  • -> PlatformCapability

struct HttpHeader has destructor

name: String

value: String

struct HttpResponse has destructor

status_code: u16

body: U8Vec

content_type: String

content_length: u64

headers: HttpHeaderVec

Check if the response was successful (2xx status)

• fn is_success:

  • &self

  • -> bool

Check if the response is a redirect (3xx status)

• fn is_redirect:

  • &self

  • -> bool

Check if the response is a client error (4xx status)

• fn is_client_error:

  • &self

  • -> bool

Check if the response is a server error (5xx status)

• fn is_server_error:

  • &self

  • -> bool

Try to convert the body to a UTF-8 string

• fn body_as_string:

  • &self

  • -> OptionString

struct HttpRequestConfig has destructor

timeout_secs: u64

max_response_size: u64

user_agent: String

headers: HttpHeaderVec

disable_tls_cert_verification: bool

Create a new config with default values

• constructor create:

  • -> HttpRequestConfig

Set timeout in seconds

• fn with_timeout:

  • self

  • arg secs: u64

  • -> HttpRequestConfig

Set maximum response size (0 = unlimited)

• fn with_max_size:

  • self

  • arg max_bytes: u64

  • -> HttpRequestConfig

Set User-Agent header

• fn with_user_agent:

  • self

  • arg ua: String

  • -> HttpRequestConfig

Add a header

• fn with_header:

  • self

  • arg name: String

  • arg value: String

  • -> HttpRequestConfig

Simple HTTP GET request with default configuration
# Arguments * url - The URL to request
# Returns * HttpResult<HttpResponse> - The response or an error

• fn http_get_default:

  • arg url: String

  • -> ResultHttpResponseHttpError

HTTP GET request using this configuration
# Arguments * url - The URL to request
# Returns * HttpResult<HttpResponse> - The response or an error

• fn http_get:

  • &self

  • arg url: String

  • -> ResultHttpResponseHttpError

Download URL to bytes with default configuration
# Arguments * url - The URL to download
# Returns * HttpResult<U8Vec> - The response body or an error

• fn download_bytes_default:

  • arg url: String

  • -> ResultU8VecHttpError

Download URL to bytes using this configuration
# Arguments * url - The URL to download
# Returns * HttpResult<U8Vec> - The response body or an error

• fn download_bytes:

  • &self

  • arg url: String

  • -> ResultU8VecHttpError

Check if a URL is reachable (HEAD request)
# Arguments * url - The URL to check
# Returns * bool - True if reachable (2xx status)

• fn is_url_reachable:

  • arg url: String

  • -> bool

struct HttpHeaderVecSlice has destructor

ptr: HttpHeader

len: usize

Static-method namespace for tfd-backed message-box dialogs.

struct MsgBox

_reserved: u8

Returns a zero-initialised handle. The struct only exists so the FFI layer can hang static methods off it.

• constructor new:

  • -> MsgBox

Show an Ok-only message box. Quotes are stripped from the message to avoid tfd shell-escape issues on some platforms.

• fn ok:

  • arg title: String

  • arg message: String

  • arg icon: MsgBoxIcon

Show an Ok/Cancel message box and return which button the user pressed.

• fn ok_cancel:

  • arg title: String

  • arg message: String

  • arg icon: MsgBoxIcon

  • arg default: OkCancel

  • -> OkCancel

Show a Yes/No message box and return which button the user pressed.

• fn yes_no:

  • arg title: String

  • arg message: String

  • arg icon: MsgBoxIcon

  • arg default: YesNo

  • -> YesNo

Convenience: Ok-only message box titled "Info" with an info icon.

• fn info:

  • arg content: String

Static-method namespace for tfd-backed file dialogs.

struct FileDialog

_reserved: u8

Returns a zero-initialised handle. The struct only exists so the FFI layer can hang static methods off it.

• constructor new:

  • -> FileDialog

Open a single file. Returns None if the user cancelled.

• fn open_file:

  • arg title: String

  • arg default_path: OptionString

  • arg filter_list: OptionFileTypeList

  • -> OptionString

Open a directory. Returns None if the user cancelled.

• fn open_directory:

  • arg title: String

  • arg default_path: OptionString

  • -> OptionString

Open multiple files. Returns None if the user cancelled.

• fn open_multiple_files:

  • arg title: String

  • arg default_path: OptionString

  • arg filter_list: OptionFileTypeList

  • -> OptionStringVec

Save-file dialog. Returns None if the user cancelled.

• fn save_file:

  • arg title: String

  • arg default_path: OptionString

  • -> OptionString

Static-method namespace for the tfd-backed color picker dialog.

struct ColorPickerDialog

_reserved: u8

Returns a zero-initialised handle. The struct only exists so the FFI layer can hang static methods off it.

• constructor new:

  • -> ColorPickerDialog

Open the system color picker. Returns None if the user cancelled.

• fn open:

  • arg title: String

  • arg default_value: OptionColorU

  • -> OptionColorU

Accessibility information for a <dialog> element.

struct DialogAriaInfo has destructor

label: OptionString

described_by: OptionString

description: OptionString

role: AccessibilityRole

modal: bool

Creates a DialogAriaInfo with the given accessible label.

• constructor create:

  • arg label: String

  • -> DialogAriaInfo

Returns a copy with the given modality flag.

• fn with_modal:

  • self

  • arg modal: bool

  • -> DialogAriaInfo

Returns a copy with aria-describedby pointing at the given node ID.

• fn with_described_by:

  • self

  • arg described_by: String

  • -> DialogAriaInfo

Returns a copy with the given accessibility role.

• fn with_role:

  • self

  • arg role: AccessibilityRole

  • -> DialogAriaInfo

Returns a copy with the given inline description.

• fn with_description:

  • self

  • arg desc: String

  • -> DialogAriaInfo

struct VirtualViewCallbackInfo

reason: VirtualViewCallbackReason

system_fonts: c_void

image_cache: c_void

window_theme: WindowTheme

bounds: HidpiAdjustedBounds

scroll_size: LogicalSize

scroll_offset: LogicalPosition

virtual_scroll_size: LogicalSize

virtual_scroll_offset: LogicalPosition

callable_ptr: c_void

measure_dom_fn: c_void

measure_dom_ctx: c_void

_abi_mut: c_void

Get the callable for FFI language bindings (Python, etc.)

• fn get_ctx:

  • &self

  • -> OptionRefAny

• fn get_bounds:

  • &self

  • -> HidpiAdjustedBounds

Measure a DOM headlessly: style + lay it out against available constraints using the host window's fonts and system style, without touching the live layout. Returns the union of all node bounds.
Use a very tall available.height (e.g. 1_000_000.0) to obtain a DOM's natural height at a fixed width - the building block for virtual-scroll sizing: measure one (or a few) item template(s), then virtual_scroll_size.height = item_height * item_count and render only the visible window of items. Each call is a full cold layout pass, so cache measured sizes per item template.
Returns LogicalSize::zero() when no measure hook was injected.

• fn measure_dom:

  • &self

  • arg dom: Dom

  • arg available: LogicalSize

  • -> LogicalSize

struct CallbackInfo

ref_data: c_void

hit_dom_node: DomNodeId

cursor_relative_to_item: OptionLogicalPosition

cursor_in_viewport: OptionLogicalPosition

changes: c_void

Get the callable for FFI language bindings (Python, etc.)
Returns the cloned OptionRefAny if a callable was set, or None if this is a native Rust callback.

• fn get_ctx:

  • &self

  • -> OptionRefAny

Returns the OpenGL context if available

• fn get_gl_context:

  • &self

  • -> OptionGlContextPtr

Add a timer to this window (applied after callback returns)

• fn add_timer:

  • &mut self

  • arg timer_id: TimerId

  • arg timer: Timer

Remove a timer from this window (applied after callback returns)

• fn remove_timer:

  • &mut self

  • arg timer_id: TimerId

Add a thread to this window (applied after callback returns)

• fn add_thread:

  • &mut self

  • arg thread_id: ThreadId

  • arg thread: Thread

Remove a thread from this window (applied after callback returns)

• fn remove_thread:

  • &mut self

  • arg thread_id: ThreadId

Stop event propagation to other nodes (W3C stopPropagation).
Remaining handlers on the current node still fire, but handlers on parent/child nodes in subsequent phases are skipped. Applied after the callback returns.

• fn stop_propagation:

  • &mut self

Stop event propagation immediately (W3C stopImmediatePropagation).
No further handlers fire, not even remaining handlers registered on the same node. Applied after the callback returns.

• fn stop_immediate_propagation:

  • &mut self

Create a new window (applied after callback returns)

• fn create_window:

  • &mut self

  • arg options: WindowCreateOptions

Close the current window (applied after callback returns)

• fn close_window:

  • &mut self

Modify the window state (applied after callback returns)

• fn modify_window_state:

  • &mut self

  • arg state: FullWindowState

Add an image to the image cache (applied after callback returns)

• fn add_image_to_cache:

  • &mut self

  • arg id: String

  • arg image: ImageRef

Remove an image from the image cache (applied after callback returns)

• fn remove_image_from_cache:

  • &mut self

  • arg id: String

Reload system fonts (applied after callback returns)
Note: This is an expensive operation that rebuilds the entire font cache

• fn reload_system_fonts:

  • &mut self

Prevent the default text input from being applied
When called in a TextInput callback, prevents the typed text from being inserted. Useful for custom validation, filtering, or text transformation.
# Example

• fn prevent_default:

  • &mut self

Open a menu (context menu or dropdown)
The menu will be displayed either as a native menu or a fallback DOM-based menu depending on the window's use_native_context_menus flag. Uses the position specified in the menu itself.
# Arguments * menu - The menu to display

• fn open_menu:

  • &mut self

  • arg menu: Menu

Open a menu at a specific position
# Arguments * menu - The menu to display * position - The position where the menu should appear (overrides menu's position)

• fn open_menu_at:

  • &mut self

  • arg menu: Menu

  • arg position: LogicalPosition

Show a tooltip at the current cursor position
Displays a simple text tooltip near the mouse cursor. The tooltip will be shown using platform-specific native APIs where available.
Platform implementations: - Windows: Uses TOOLTIPS_CLASS Win32 control - macOS: Uses NSPopover or custom NSWindow with tooltip styling - X11: Creates transient window with _NET_WM_WINDOW_TYPE_TOOLTIP - Wayland: Uses zwlr_layer_shell_v1 with overlay layer
# Arguments * text - The tooltip text to display
# Example

• fn show_tooltip:

  • &mut self

  • arg text: String

Show a tooltip at a specific position
# Arguments * text - The tooltip text to display * position - The position where the tooltip should appear (in window coordinates)
# Example

• fn show_tooltip_at:

  • &mut self

  • arg text: String

  • arg position: LogicalPosition

Hide the currently displayed tooltip
# Example

• fn hide_tooltip:

  • &mut self

Open a menu positioned relative to the currently hit node
Convenience method for opening a menu at the element that triggered the callback. Equivalent to open_menu_for_node(menu, info.get_hit_node()).
# Arguments * menu - The menu to display
# Returns * true if the menu was queued for opening * false if no node is currently hit or it has no layout information

• fn open_menu_for_hit_node:

  • &mut self

  • arg menu: Menu

  • -> bool

Get current window flags

• fn get_current_window_flags:

  • &self

  • -> WindowFlags

Get the current scroll offset for the hit node (if it's scrollable)
Convenience method that uses the hit_dom_node from this callback. Use get_scroll_offset_for_node if you need to query a specific node.

• fn get_scroll_offset:

  • &self

  • -> OptionLogicalPosition

Get current keyboard state

• fn get_current_keyboard_state:

  • &self

  • -> KeyboardState

Get current mouse state

• fn get_current_mouse_state:

  • &self

  • -> MouseState

• fn get_cursor_relative_to_node:

  • &self

  • -> OptionCursorNodePosition

• fn get_cursor_relative_to_viewport:

  • &self

  • -> OptionLogicalPosition

Get the current cursor position in logical coordinates relative to the window

• fn get_cursor_position:

  • &self

  • -> OptionLogicalPosition

Get the current cursor position in screen (global/desktop) coordinates

• fn get_cursor_position_screen:

  • &self

  • -> OptionScreenPosition

Get the drag delta from drag start to current position, in window-local logical coordinates

• fn get_drag_delta:

  • &self

  • -> OptionDragDelta

Get the total drag delta in screen coordinates (from drag start to now)

• fn get_drag_delta_screen:

  • &self

  • -> OptionDragDelta

Get the incremental screen drag delta since the last frame (robust against external position changes)

• fn get_drag_delta_screen_incremental:

  • &self

  • -> OptionDragDelta

Begin an interactive window move (CSD titlebar drag). On Wayland this delegates to the compositor; on other platforms it is a no-op (use get_drag_delta instead).

• fn begin_interactive_move:

  • &mut self

Get all connected monitors (cached, no syscall). Returns the monitor list from the app-level cache. Updated automatically when monitors are added/removed.

• fn get_monitors:

  • &self

  • -> MonitorVec

Get the monitor the window is currently displayed on. Returns the full Monitor struct with DPI, size, position, etc. Returns None if monitor information is unavailable.

• fn get_current_monitor:

  • &self

  • -> OptionMonitor

• fn get_current_time:

  • &self

  • -> Instant

Check if any node in a specific DOM is focused

• fn is_dom_focused:

  • &self

  • arg dom_id: DomId

  • -> bool

Check if pen is currently in contact with surface

• fn is_pen_in_contact:

  • &self

  • -> bool

Check if pen is in eraser mode

• fn is_pen_eraser:

  • &self

  • -> bool

Check if pen barrel button is pressed

• fn is_pen_barrel_button_pressed:

  • &self

  • -> bool

Set focus to a node matching a CSS path

• fn set_focus_to_path:

  • &mut self

  • arg dom_id: DomId

  • arg css_path: CssPath

Move focus to next focusable element in tab order

• fn focus_next:

  • &mut self

Move focus to previous focusable element in tab order

• fn focus_previous:

  • &mut self

Move focus to first focusable element

• fn focus_first:

  • &mut self

Move focus to last focusable element

• fn focus_last:

  • &mut self

Remove focus from all elements

• fn clear_focus:

  • &mut self

Check if a drag gesture is currently active
Convenience method that queries the gesture manager.

• fn is_dragging:

  • &self

  • -> bool

Check if a node or file drag is currently active
Returns true if either a node drag or file drag is in progress.

• fn is_drag_active:

  • &self

  • -> bool

Check if a node drag is specifically active

• fn is_node_drag_active:

  • &self

  • -> bool

Check if a file drag is specifically active

• fn is_file_drag_active:

  • &self

  • -> bool

Check if there's sufficient mouse history for gesture detection (at least 2 frames)

• fn has_sufficient_history_for_gestures:

  • &self

  • -> bool

Change the text content of a node (applied after callback returns)
This method was previously called set_string_contents in older API versions.
# Arguments * node_id - The text node to modify (DomNodeId containing both DOM and node IDs) * text - The new text content
# Example

• fn change_node_text:

  • &mut self

  • arg node_id: DomNodeId

  • arg text: String

Re-render an image callback (for resize/animation updates)
This triggers re-invocation of the RenderImageCallback associated with the node. Useful for: - Responding to window resize (image needs to match new size) - Animation frames (update OpenGL texture each frame) - Interactive content (user input changes rendering)
# Example

• fn update_image_callback:

  • &mut self

  • arg dom_id: DomId

  • arg node_id: NodeId

Re-render ALL image callbacks across all DOMs (applied after callback returns)
This is the most efficient way to update animated GL textures from a timer. Triggers only texture re-rendering - no DOM rebuild or display list resubmission.
# Example

• fn update_all_image_callbacks:

  • &mut self

Trigger re-rendering of a VirtualView (applied after callback returns)
This forces the VirtualView to call its layout callback with reason DomRecreated and submit a new display list to WebRender. The VirtualView's pipeline will be updated without affecting other parts of the window.
Useful for: - Live preview panes (update when source code changes) - Dynamic content that needs manual refresh - Editor previews (re-parse and display new DOM)
# Example

• fn trigger_virtual_view_rerender:

  • &mut self

  • arg dom_id: DomId

  • arg node_id: NodeId

Find a node by ID attribute in the layout tree
Returns the NodeId of the first node with the given ID attribute, or None if not found.
# Example

• fn get_node_id_by_id_attribute:

  • &self

  • arg dom_id: DomId

  • arg id: String

  • -> NodeHierarchyItemId

Get the parent node of the given node
Returns None if the node has no parent (i.e., it's the root node)

• fn get_parent_node:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> NodeHierarchyItemId

Get the next sibling of the given node
Returns None if the node has no next sibling

• fn get_next_sibling_node:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> NodeHierarchyItemId

Get the previous sibling of the given node
Returns None if the node has no previous sibling

• fn get_previous_sibling_node:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> NodeHierarchyItemId

Get the first child of the given node
Returns None if the node has no children

• fn get_first_child_node:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> NodeHierarchyItemId

Get the last child of the given node
Returns None if the node has no children

• fn get_last_child_node:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> NodeHierarchyItemId

Change the image mask of a node (applied after callback returns)

• fn change_node_image_mask:

  • &mut self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • arg mask: ImageMask

Set a single CSS property on a node (convenience method for widgets)
This is a helper method that wraps change_node_css_properties for the common case of setting a single property. It uses the hit node's DOM ID automatically.
# Arguments * node_id - The node to set the property on (uses hit node's DOM ID) * property - The CSS property to set
# Example

• fn set_css_property:

  • &mut self

  • arg node_id: DomNodeId

  • arg property: CssProperty

Scroll a node to a specific position (applied after callback returns)

• fn scroll_to:

  • &mut self

  • arg dom_id: DomId

  • arg node_id: NodeHierarchyItemId

  • arg position: LogicalPosition

Insert text at the current cursor position in a text node
This operation is transactional - the text will be inserted after the callback returns. If there's a selection, it will be replaced with the inserted text.
# Arguments * dom_id - The DOM containing the text node * node_id - The node to insert text into * text - The text to insert
# Example

• fn insert_text:

  • &mut self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • arg text: String

Add an additional cursor at the specified position (multi-cursor editing).
Returns the SelectionId of the new cursor.

• fn add_cursor:

  • &mut self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • arg cursor: TextCursor

  • -> SelectionId

Add an additional selection range (multi-cursor editing).
Returns the SelectionId of the new selection.

• fn add_selection_range:

  • &mut self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • arg range: SelectionRange

  • -> SelectionId

Remove a specific selection/cursor by its stable SelectionId.

• fn remove_selection_by_id:

  • &mut self

  • arg selection_id: SelectionId

  • -> bool

Get the number of active cursors/selections in the MultiCursorState.

• fn get_selection_count:

  • &self

  • arg dom_id: DomId

  • -> usize

Open a menu positioned relative to a specific DOM node
This is useful for dropdowns, combo boxes, and context menus that should appear near a specific UI element. The menu will be positioned below the node by default.
# Arguments * menu - The menu to display * node_id - The DOM node to position the menu relative to
# Returns * true if the menu was queued for opening * false if the node doesn't exist or has no layout information

• fn open_menu_for_node:

  • &mut self

  • arg menu: Menu

  • arg node_id: DomNodeId

  • -> bool

• fn get_node_size:

  • &self

  • arg node_id: DomNodeId

  • -> OptionLogicalSize

• fn get_node_position:

  • &self

  • arg node_id: DomNodeId

  • -> OptionLogicalPosition

Get the bounding rectangle of a node (position + size)
This is particularly useful for menu positioning, where you need to know where a UI element is to popup a menu relative to it.

• fn get_node_rect:

  • &self

  • arg node_id: DomNodeId

  • -> OptionLogicalRect

Get the bounding rectangle of the hit node
Convenience method that combines get_hit_node() and get_node_rect(). Useful for menu positioning based on the clicked element.

• fn get_hit_node_rect:

  • &self

  • -> OptionLogicalRect

Get a reference to a timer

• fn get_timer:

  • &self

  • arg timer_id: TimerId

  • -> OptionTimer

Get all timer IDs

• fn get_timer_ids:

  • &self

  • -> TimerIdVec

Get a reference to a thread

• fn get_thread:

  • &self

  • arg thread_id: ThreadId

  • -> OptionThread

Get all thread IDs

• fn get_thread_ids:

  • &self

  • -> ThreadIdVec

Get all DOM IDs that have layout results

• fn get_dom_ids:

  • &self

  • -> DomIdVec

• fn get_hit_node:

  • &self

  • -> DomNodeId

• fn get_parent:

  • &self

  • arg node_id: DomNodeId

  • -> OptionDomNodeId

• fn get_previous_sibling:

  • &self

  • arg node_id: DomNodeId

  • -> OptionDomNodeId

• fn get_next_sibling:

  • &self

  • arg node_id: DomNodeId

  • -> OptionDomNodeId

• fn get_first_child:

  • &self

  • arg node_id: DomNodeId

  • -> OptionDomNodeId

• fn get_last_child:

  • &self

  • arg node_id: DomNodeId

  • -> OptionDomNodeId

• fn get_dataset:

  • &mut self

  • arg node_id: DomNodeId

  • -> OptionRefAny

• fn get_node_id_of_root_dataset:

  • &mut self

  • arg search_key: RefAny

  • -> OptionDomNodeId

• fn get_string_contents:

  • &self

  • arg node_id: DomNodeId

  • -> OptionString

Get the current selection state for a DOM

• fn get_selection:

  • &self

  • arg dom_id: DomId

  • -> OptionSelectionState

Check if a DOM has any selection

• fn has_selection:

  • &self

  • arg dom_id: DomId

  • -> bool

Get the primary cursor for a DOM (first in selection list)

• fn get_primary_cursor:

  • &self

  • arg dom_id: DomId

  • -> OptionTextCursor

Get all selection ranges (excludes plain cursors)

• fn get_selection_ranges:

  • &self

  • arg dom_id: DomId

  • -> SelectionRangeVec

Get full current window state (immutable reference)

• fn get_current_window_state:

  • &self

  • -> FullWindowState

Get previous window flags

• fn get_previous_window_flags:

  • &self

  • -> OptionWindowFlags

Get previous keyboard state

• fn get_previous_keyboard_state:

  • &self

  • -> OptionKeyboardState

Get previous mouse state

• fn get_previous_mouse_state:

  • &self

  • -> OptionMouseState

• fn get_current_window_handle:

  • &self

  • -> RawWindowHandle

Get the layout rectangle of the currently hit node (in logical coordinates)

• fn get_hit_node_layout_rect:

  • &self

  • -> OptionLogicalRect

Get the computed CSS property for a specific DOM node
This queries the CSS property cache and returns the resolved property value for the given node, taking into account: - User overrides (from callbacks) - Node state (:hover, :active, :focus) - CSS rules from stylesheets - Cascaded properties from parents - Inline styles
# Arguments * node_id - The DOM node to query * property_type - The CSS property type to retrieve
# Returns * Some(CssProperty) if the property is set on this node * None if the property is not set (will use default value)

• fn get_computed_css_property:

  • &self

  • arg node_id: DomNodeId

  • arg property_type: CssPropertyType

  • -> OptionCssProperty

Get the computed width of a node from CSS
Convenience method for getting the CSS width property.

• fn get_computed_width:

  • &self

  • arg node_id: DomNodeId

  • -> OptionCssProperty

Get the computed height of a node from CSS
Convenience method for getting the CSS height property.

• fn get_computed_height:

  • &self

  • arg node_id: DomNodeId

  • -> OptionCssProperty

• fn get_system_time_fn:

  • &self

  • -> GetSystemTimeCallback

Check if a specific node is currently focused

• fn is_node_focused:

  • &self

  • arg node_id: DomNodeId

  • -> bool

Get current pen/stylus state if a pen is active

• fn get_pen_state:

  • &self

  • -> OptionPenState

Get current pen pressure (0.0 to 1.0) Returns None if no pen is active, Some(0.5) for mouse

• fn get_pen_pressure:

  • &self

  • -> OptionF32

Get current pen tilt angles (x_tilt, y_tilt) in degrees Returns None if no pen is active

• fn get_pen_tilt:

  • &self

  • -> OptionPenTilt

Get the event ID of the current event

• fn get_current_event_id:

  • &self

  • -> OptionU64

Set focus to a specific DOM node by ID

• fn set_focus_to_node:

  • &mut self

  • arg dom_id: DomId

  • arg node_id: NodeId

Get the currently focused node (if any)
Returns None if no node has focus.

• fn get_focused_node:

  • &self

  • -> OptionDomNodeId

Check if a specific node has focus

• fn has_focus:

  • &self

  • arg node_id: DomNodeId

  • -> bool

Get the currently hovered file (if drag-drop is in progress)
Returns None if no file is being hovered over the window.

• fn get_hovered_file:

  • &self

  • -> OptionString

Get the currently dropped file (if a file was just dropped)
This is a one-shot value that is cleared after event processing. Returns None if no file was dropped this frame.

• fn get_dropped_file:

  • &self

  • -> OptionString

Get the node being dragged (if any)

• fn get_dragged_node:

  • &self

  • -> OptionDomNodeId

Get the file path being dragged (if any)

• fn get_dragged_file:

  • &self

  • -> OptionString

Get the current drag/drop state (if any)
Returns None if no drag is active, or Some with drag details.

• fn get_drag_state:

  • &self

  • -> OptionDragState

Get the current scroll offset for a specific node (if it's scrollable)

• fn get_scroll_offset_for_node:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> OptionLogicalPosition

Get the scroll delta for a node in the current frame (for scroll event detection)

• fn get_scroll_delta:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> OptionLogicalPosition

Check if a node had scroll activity this frame

• fn had_scroll_activity:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> bool

Get the scroll state (container rect, content rect, current offset) for a node

• fn get_scroll_state:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> OptionScrollState

Inspect the current selection range that would be affected by paste
Returns the selection range that will be replaced when pasting. Returns None if no selection exists (paste will insert at cursor).

• fn inspect_paste_target_range:

  • &self

  • arg target: DomNodeId

  • -> OptionSelectionRange

Inspect what text would be selected by Select All operation
Returns the full text content and the range that would be selected.

• fn inspect_select_all_changeset:

  • &self

  • arg target: DomNodeId

  • -> OptionSelectAllResult

Inspect what would be deleted by a backspace/delete operation
Uses the pure functions from text3::edit::inspect_delete() to determine what would be deleted without actually performing the deletion.
Returns (range_to_delete, deleted_text). - forward=true: Delete key (delete character after cursor) - forward=false: Backspace key (delete character before cursor)
# Example

• fn inspect_delete_changeset:

  • &self

  • arg target: DomNodeId

  • arg forward: bool

  • -> OptionDeleteResult

Get clipboard content from system clipboard (available during paste operations)
This returns content that was read from the system clipboard when Ctrl+V was pressed. It's only available in On::Paste callbacks or similar clipboard-related callbacks.
Use this to inspect what will be pasted before allowing or modifying the paste operation.

• fn get_clipboard_content:

  • &self

  • -> OptionClipboardContent

Inspect a pending copy operation
Returns the clipboard content that would be copied from the current selection. Use this to validate or transform content before copying.

• fn inspect_copy_changeset:

  • &self

  • arg target: DomNodeId

  • -> OptionClipboardContent

Inspect a pending cut operation
Returns the clipboard content that would be cut (copied + deleted). Use this to validate or transform content before cutting.

• fn inspect_cut_changeset:

  • &self

  • arg target: DomNodeId

  • -> OptionClipboardContent

Override clipboard content for copy/cut operations
This sets custom content that will be written to the system clipboard. Use this in On::Copy or On::Cut callbacks to modify what gets copied.
# Arguments * content - The clipboard content to write to system clipboard
# Example

• fn set_clipboard_content:

  • &mut self

  • arg content: ClipboardContent

Set/modify the clipboard content before a copy operation
Use this to transform clipboard content before copying. The change is queued and will be applied after the callback returns, if preventDefault() was not called.
# Example

• fn set_copy_content:

  • &mut self

  • arg target: DomNodeId

  • arg content: ClipboardContent

Set/modify the clipboard content before a cut operation
Similar to set_copy_content but for cut operations. The change is queued and will be applied after the callback returns.

• fn set_cut_content:

  • &mut self

  • arg target: DomNodeId

  • arg content: ClipboardContent

Override the selection range for select-all operation
Use this to limit what gets selected (e.g., only select visible text). The change is queued and will be applied after the callback returns.

• fn set_select_all_range:

  • &mut self

  • arg target: DomNodeId

  • arg range: SelectionRange

Get the current text content of a node
Helper for inspecting text before operations.

• fn get_node_text_content:

  • &self

  • arg target: DomNodeId

  • -> OptionString

Get the current cursor position in a node
Returns the text cursor position if the node is focused.

• fn get_node_cursor_position:

  • &self

  • arg target: DomNodeId

  • -> OptionTextCursor

Get the current selection ranges in a node
Returns all active selection ranges for the specified DOM.

• fn get_node_selection_ranges:

  • &self

  • arg target: DomNodeId

  • -> SelectionRangeVec

Check if a specific node has an active selection
This checks if the specific node (identified by DomNodeId) has a selection, as opposed to has_selection(DomId) which checks the entire DOM.

• fn node_has_selection:

  • &self

  • arg target: DomNodeId

  • -> bool

Get the length of text in a node
Useful for bounds checking in custom operations.

• fn get_node_text_length:

  • &self

  • arg target: DomNodeId

  • -> OptionUsize

Check if undo is available for a specific node
Returns true if there is at least one undoable operation in the stack.

• fn can_undo:

  • &self

  • arg node_id: NodeId

  • -> bool

Check if redo is available for a specific node
Returns true if there is at least one redoable operation in the stack.

• fn can_redo:

  • &self

  • arg node_id: NodeId

  • -> bool

Get the text that would be restored by undo for a specific node
Returns the pre-state text content that would be restored if undo is performed. Returns None if no undo operation is available.

• fn get_undo_text:

  • &self

  • arg node_id: NodeId

  • -> OptionString

Get the text that would be restored by redo for a specific node
Returns the pre-state text content that would be restored if redo is performed. Returns None if no redo operation is available.

• fn get_redo_text:

  • &self

  • arg node_id: NodeId

  • -> OptionString

Inspect a pending undo operation
Returns the full UndoableOperation that would be undone. Use this to inspect the changeset and pre-state before allowing undo.

• fn inspect_undo_operation:

  • &self

  • arg node_id: NodeId

  • -> OptionUndoableOperation

Inspect a pending redo operation
Returns the full UndoableOperation that would be redone. Use this to inspect the changeset and pre-state before allowing redo.

• fn inspect_redo_operation:

  • &self

  • arg node_id: NodeId

  • -> OptionUndoableOperation

Inspect where the cursor would move when pressing left arrow
Returns the new cursor position that would result from moving left. Returns None if the cursor is already at the start of the document.
# Arguments * target - The node containing the cursor
# Example


• fn inspect_move_cursor_left:

  • &self

  • arg target: DomNodeId

  • -> OptionTextCursor

Inspect where the cursor would move when pressing right arrow
Returns the new cursor position that would result from moving right. Returns None if the cursor is already at the end of the document.

• fn inspect_move_cursor_right:

  • &self

  • arg target: DomNodeId

  • -> OptionTextCursor

Inspect where the cursor would move when pressing up arrow
Returns the new cursor position that would result from moving up one line. Returns None if the cursor is already on the first line.

• fn inspect_move_cursor_up:

  • &self

  • arg target: DomNodeId

  • -> OptionTextCursor

Inspect where the cursor would move when pressing down arrow
Returns the new cursor position that would result from moving down one line. Returns None if the cursor is already on the last line.

• fn inspect_move_cursor_down:

  • &self

  • arg target: DomNodeId

  • -> OptionTextCursor

Inspect where the cursor would move when pressing Home key
Returns the cursor position at the start of the current line.

• fn inspect_move_cursor_to_line_start:

  • &self

  • arg target: DomNodeId

  • -> OptionTextCursor

Inspect where the cursor would move when pressing End key
Returns the cursor position at the end of the current line.

• fn inspect_move_cursor_to_line_end:

  • &self

  • arg target: DomNodeId

  • -> OptionTextCursor

Inspect where the cursor would move when pressing Ctrl+Home
Returns the cursor position at the start of the document.

• fn inspect_move_cursor_to_document_start:

  • &self

  • arg target: DomNodeId

  • -> OptionTextCursor

Inspect where the cursor would move when pressing Ctrl+End
Returns the cursor position at the end of the document.

• fn inspect_move_cursor_to_document_end:

  • &self

  • arg target: DomNodeId

  • -> OptionTextCursor

Inspect what text would be deleted by backspace (including Shift+Backspace)
Returns (range_to_delete, deleted_text). This is a convenience wrapper around inspect_delete_changeset(target, false).

• fn inspect_backspace:

  • &self

  • arg target: DomNodeId

  • -> OptionDeleteResult

Inspect what text would be deleted by delete key
Returns (range_to_delete, deleted_text). This is a convenience wrapper around inspect_delete_changeset(target, true).

• fn inspect_delete:

  • &self

  • arg target: DomNodeId

  • -> OptionDeleteResult

Move cursor left (arrow left key)
# Arguments * target - The node containing the cursor * extend_selection - If true, extends selection (Shift+Left); if false, moves cursor
# Example

• fn move_cursor_left:

  • &mut self

  • arg target: DomNodeId

  • arg extend_selection: bool

Move cursor right (arrow right key)

• fn move_cursor_right:

  • &mut self

  • arg target: DomNodeId

  • arg extend_selection: bool

Move cursor up (arrow up key)

• fn move_cursor_up:

  • &mut self

  • arg target: DomNodeId

  • arg extend_selection: bool

Move cursor down (arrow down key)

• fn move_cursor_down:

  • &mut self

  • arg target: DomNodeId

  • arg extend_selection: bool

Move cursor to line start (Home key)

• fn move_cursor_to_line_start:

  • &mut self

  • arg target: DomNodeId

  • arg extend_selection: bool

Move cursor to line end (End key)

• fn move_cursor_to_line_end:

  • &mut self

  • arg target: DomNodeId

  • arg extend_selection: bool

Move cursor to document start (Ctrl+Home)

• fn move_cursor_to_document_start:

  • &mut self

  • arg target: DomNodeId

  • arg extend_selection: bool

Move cursor to document end (Ctrl+End)

• fn move_cursor_to_document_end:

  • &mut self

  • arg target: DomNodeId

  • arg extend_selection: bool

Delete text backward (backspace or Shift+Backspace)
Queues a backspace operation to be applied after the callback. Use inspect_backspace() to see what would be deleted.

• fn delete_backward:

  • &mut self

  • arg target: DomNodeId

Delete text forward (delete key)
Queues a delete operation to be applied after the callback. Use inspect_delete() to see what would be deleted.

• fn delete_forward:

  • &mut self

  • arg target: DomNodeId

Get all direct children of a node
Returns a vector of NodeIds for all direct children of the specified node. Does not recurse into children of children (non-recursive).

• fn get_all_children_nodes:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> NodeHierarchyItemIdVec

Get the number of direct children of a node
Returns the count of direct children for the specified node. This is more efficient than get_all_children_nodes().len() when you only need the count.

• fn get_children_count:

  • &self

  • arg dom_id: DomId

  • arg node_id: NodeId

  • -> usize

Get the HTML tag name of a node
Returns the tag name (e.g., 'div', 'body', 'p', 'input') of the specified node. Returns None if the node doesn't exist.

• fn get_node_tag_name:

  • &self

  • arg node_id: DomNodeId

  • -> OptionString

Get a specific attribute value of a node
Returns the value of the specified attribute on the node. Supports standard HTML attributes like 'id', 'class', 'href', 'src', 'alt', etc. Also supports custom data-* attributes and aria-* attributes.
# Arguments * node_id - The DOM node to query * attr_name - The attribute name to look up (e.g., 'id', 'class', 'href')
# Returns * Some(String) if the attribute exists * None if the attribute doesn't exist or the node doesn't exist

• fn get_node_attribute:

  • &self

  • arg node_id: DomNodeId

  • arg attr_name: String

  • -> OptionString

Get all CSS classes of a node
Returns a vector of all CSS class names applied to the node.

• fn get_node_classes:

  • &self

  • arg node_id: DomNodeId

  • -> StringVec

Get the ID attribute of a node
Convenience method for getting the 'id' attribute. Equivalent to get_node_attribute(node_id, 'id').

• fn get_node_id:

  • &self

  • arg node_id: DomNodeId

  • -> OptionString

Take a CPU-rendered screenshot of a DOM
Renders the specified DOM to a PNG image using the CPU renderer. This captures only the DOM content without window decorations. Useful for visual regression testing (reftest) and documentation.
# Arguments * dom_id - The DOM to screenshot
# Returns * Ok(Vec<u8>) - PNG-encoded image data * Err(String) - Error message if rendering failed

• fn take_screenshot:

  • &self

  • arg dom_id: DomId

  • -> ResultU8VecString

Take a CPU-rendered screenshot and save it to a file
Convenience method that combines take_screenshot with file writing.
# Arguments * dom_id - The DOM to screenshot * path - The file path to save the PNG to

• fn take_screenshot_to_file:

  • &self

  • arg dom_id: DomId

  • arg path: String

  • -> ResultVoidString

Take a native OS-level screenshot of the window including decorations
Captures the actual window as it appears on screen, including the title bar, window borders, and any OS-provided window decorations. This is useful for documentation, tutorials, or visual testing.
# Platform Support - macOS: Uses screencapture command with window ID - Windows: Uses PrintWindow API - Linux: Uses XGetImage (X11)
# Arguments * path - The file path to save the PNG screenshot to
# Returns * Ok(()) - Screenshot saved successfully * Err(String) - Error message if screenshot failed

• fn take_native_screenshot:

  • &self

  • arg path: String

  • -> ResultVoidString

Take a native OS-level screenshot and return the PNG data as bytes
Same as take_native_screenshot but returns the PNG data directly instead of saving to a file.
# Returns * Ok(Vec<u8>) - PNG-encoded image data * Err(String) - Error message if screenshot failed

• fn take_native_screenshot_bytes:

  • &self

  • -> ResultU8VecString

Take a native OS-level screenshot and return as a Base64 data URI
Returns the screenshot as a 'data:image/png;base64,...' string that can be directly used in HTML img tags or JSON responses.
# Returns * Ok(String) - Base64 data URI string * Err(String) - Error message if screenshot failed

• fn take_native_screenshot_base64:

  • &self

  • -> ResultStringString

Take a CPU-rendered screenshot and return as a Base64 data URI
Returns the screenshot as a 'data:image/png;base64,...' string. This is the software-rendered version without window decorations.
# Returns * Ok(String) - Base64 data URI string * Err(String) - Error message if rendering failed

• fn take_screenshot_base64:

  • &self

  • arg dom_id: DomId

  • -> ResultStringString

Get the current text changeset being processed (if any)
This allows callbacks to inspect what text input is about to be applied. Returns None if no text input is currently being processed.
Use set_text_changeset() to modify the text that will be inserted, and prevent_default() to block the text input entirely.

• fn get_text_changeset:

  • &self

  • -> OptionPendingTextEdit

Accept the current drop operation on this node.
W3C equivalent: calling event.preventDefault() in a DragOver handler. This signals that the current drop target can accept the dragged data. Must be called from a DragOver or DragEnter callback for the Drop event to fire on this node.

• fn accept_drop:

  • &mut self

Get the list of MIME types available on the current drag operation.
W3C equivalent: dataTransfer.types Returns an empty vec if no drag is active or no data is set.

• fn get_drag_types:

  • &self

  • -> StringVec

Set drag data for a MIME type on the active drag operation.
W3C equivalent: dataTransfer.setData(type, data) Should be called from a DragStart callback to populate the drag data.

• fn set_drag_data:

  • &mut self

  • arg mime_type: String

  • arg data: U8Vec

Set the drop effect for the current drag operation.
W3C equivalent: dataTransfer.dropEffect = "none" | "copy" | "link" | "move". Should be called from a DragOver or DragEnter callback on the drop target.

• fn set_drop_effect:

  • &mut self

  • arg effect: DropEffect

True iff the gesture manager classified the current event sequence as a double-click / double-tap.

• fn was_double_clicked:

  • &self

  • -> bool

Returns the dominant direction of the current swipe gesture, if any. Detection uses the touch / pointer trajectory and a velocity threshold; on iOS / Android the platform backend may override the in-process detector with a native gesture-recognizer result.

• fn get_swipe_direction:

  • &self

  • -> OptionGestureDirection

Returns the active pinch gesture (scale + center + distances), if any.

• fn get_pinch:

  • &self

  • -> OptionDetectedPinch

Returns the active rotation gesture (radians + center), if any.

• fn get_rotation:

  • &self

  • -> OptionDetectedRotation

Returns the active long-press, if the user is currently holding a pointer in place beyond the configured threshold.

• fn get_long_press:

  • &self

  • -> OptionDetectedLongPress

Get the most recent geolocation fix, or None if no GeolocationProbe is mounted or no platform backend has delivered a fix yet. The fix is kept live by the platform backends (Android FusedLocationProvider, iOS/macOS CLLocationManager) via the async fix channel that the layout pass folds into the manager - so a callback can read the user's position to, e.g., place a "you are here" marker on a map.

• fn get_location_fix:

  • &self

  • -> OptionLocationFix

Get the most recent biometric-auth result, or None if no request_biometric_auth has completed yet. Kept live by the platform backends (iOS/macOS LAContext, Android BiometricPrompt, Windows UserConsentVerifier) via the async result channel the layout pass folds into the manager - so a callback can unlock a vault / settings panel once the user authenticates.

• fn get_biometric_result:

  • &self

  • -> OptionBiometricResult

Get the device's biometric capability (sync probe): Face, Fingerprint, Iris, or NotAvailable. Lets a callback decide whether to even offer a biometric unlock before requesting one (no OS prompt is shown - this just reads the cached probe).

• fn get_biometric_kind:

  • &self

  • -> BiometricKind

Request a biometric-auth prompt (Face ID / Touch ID / Android BiometricPrompt / Windows Hello). Returns immediately - the OS draws its own modal asynchronously; the outcome arrives on a later frame and is read via [CallbackInfo::get_biometric_result]. Call this from, e.g., an unlock button's on_click. The prompt configures the reason text, cancel label, and whether the OS passcode fallback is allowed. (No platform backend reports a real outcome yet - the request currently resolves to BiometricResult::Unavailable; the iOS/macOS/Android backends land in a later tick.)

• fn request_biometric_auth:

  • &mut self

  • arg prompt: BiometricPrompt

Store secret under key in the OS keyring (Keychain / KeyStore / libsecret / CredentialLocker). When require_biometry is set, a later keyring_get of this key triggers the OS biometric prompt. Returns immediately; the outcome arrives via get_keyring_result() on a later frame.

• fn keyring_store:

  • &mut self

  • arg key: String

  • arg secret: String

  • arg require_biometry: bool

Read the secret stored under key. A biometry-bound item shows the OS prompt first; the secret (or a denial) arrives via get_keyring_result() on a later frame.

• fn keyring_get:

  • &mut self

  • arg key: String

Remove the item stored under key from the OS keyring (no-op if absent). The outcome arrives via get_keyring_result().

• fn keyring_delete:

  • &mut self

  • arg key: String

Get the most recent keyring outcome, or None until the first op completes. Read after a keyring_store/get/delete to observe the result - e.g. the revealed secret from a keyring_get (KeyringResult::Retrieved).

• fn get_keyring_result:

  • &self

  • -> OptionKeyringResult

Get the latest motion-sensor reading for kind (Accelerometer / Gyroscope / Magnetometer), or None if no platform backend has delivered one. Kept live by the sensor backends (iOS CoreMotion, Android SensorManager) via the async channel the layout pass folds into the manager - so a callback can drive tilt / shake / compass UI.

• fn get_sensor_reading:

  • &self

  • arg kind: SensorKind

  • -> OptionSensorReading

Get the latest state of the gamepad id (button bitset + analog axes), or None if no pad with that id has connected. Kept live by the controller backend (gilrs / iOS GCController / Android InputDevice) via the async channel the layout pass folds into the manager - so a callback can drive movement / menu UI. For the common single-controller case, [CallbackInfo::get_primary_gamepad] skips the id bookkeeping.

• fn get_gamepad_state:

  • &self

  • arg id: GamepadId

  • -> OptionGamepadState

Get the first currently-connected gamepad, or None if none is connected - the convenient single-controller accessor.

• fn get_primary_gamepad:

  • &self

  • -> OptionGamepadState

Get the current Wacom tablet-pad state (ExpressKeys + touch-ring), or None if no pad backend has delivered one. (The pen's own wacom features - eraser / barrel button / barrel roll / tilt / pressure - are in [CallbackInfo::get_pen_state].) Kept live by the platform pad backend (Wintab / libwacom+libinput / macOS tablet NSEvents).

• fn get_wacom_pad:

  • &self

  • -> OptionWacomPadState

The safe-area insets (notch / system-UI margins) for this window, in logical px - lay out interactive content within them so it isn't hidden by a notch / rounded corners / status bar. Zero where the platform or window has no inset. Set by the platform shell (macOS NSScreen notch, iOS UIView.safeAreaInsets, Android WindowInsets).

• fn get_safe_area_insets:

  • &self

  • -> SafeAreaInsets

Enumerate every font the layout engine currently has loaded in its font cache.
Returns one [LoadedFont](azul_core::resources::LoadedFont) descriptor per loaded face. The font_hash field of each descriptor is identical to the font_hash carried by DisplayListItem::Text glyph runs, so a callback can correlate a loaded font with the text that uses it and then pull the raw bytes via [get_loaded_font_bytes](Self::get_loaded_font_bytes).
The list includes fallback faces that were resolved during layout, not just the families named in the source CSS.

• fn get_loaded_fonts:

  • &self

  • -> LoadedFontVec

Retrieve the raw source bytes (TTF / OTF / TTC, etc.) for a loaded font, looked up by the font_hash returned from [get_loaded_fonts](Self::get_loaded_fonts) (or carried on a DisplayListItem::Text glyph run).
Returns None if no loaded font matches font_hash, or if the matching font did not retain its source bytes (e.g. a test-only font; production fonts loaded from disk retain an mmap-backed handle and always succeed). The returned bytes can be embedded directly into a generated document.

• fn get_loaded_font_bytes:

  • &self

  • arg font_hash: u64

  • -> OptionU8Vec

Deepest node currently under the mouse pointer (MWA-B8). Anchor for drag auto-scroll when there is no focused node - node drags and OS file hovers scroll the container under the pointer, not the focused text field. Measure a DOM headlessly: style + lay it out against available constraints (this window's fonts / system style) without touching the live layout. Returns the union of all node bounds - use a very tall available.height (e.g. 1_000_000.0) to get a DOM's natural height at a given width. Primary use: sizing VirtualView items to compute the virtual scroll extent. A full cold layout pass per call - cache per item template.

• fn measure_dom:

  • &self

  • arg dom: Dom

  • arg available: LogicalSize

  • -> LogicalSize

Wrapper around the layout callback function pointer. For FFI languages (Python, Java, etc.), the RefAny passed to the callback contains both the user data and the callback function object.

struct LayoutCallback

cb: LayoutCallbackType

ctx: OptionRefAny

• constructor create:

  • arg cb: LayoutCallbackType

  • -> LayoutCallback

struct LayoutCallbackInfo

ref_data: c_void

window_size: WindowSize

theme: WindowTheme

relayout_reason: RelayoutReason

callable_ptr: c_void

_abi_mut: c_void

Returns what triggered the current layout() invocation.

• fn relayout_reason:

  • &self

  • -> RelayoutReason

Get the callable for FFI language bindings (Python, etc.)

• fn get_ctx:

  • &self

  • -> OptionRefAny

• fn get_gl_context:

  • &self

  • -> OptionGlContextPtr

Returns true if the window width is less than the given pixel value
# Example

• fn window_width_less_than:

  • &self

  • arg px: f32

  • -> bool

Returns true if the window width is greater than the given pixel value

• fn window_width_greater_than:

  • &self

  • arg px: f32

  • -> bool

Returns true if the window width is between min and max (inclusive)

• fn window_width_between:

  • &self

  • arg min_px: f32

  • arg max_px: f32

  • -> bool

Returns true if the window height is less than the given pixel value

• fn window_height_less_than:

  • &self

  • arg px: f32

  • -> bool

Returns true if the window height is greater than the given pixel value

• fn window_height_greater_than:

  • &self

  • arg px: f32

  • -> bool

Returns true if the window height is between min and max (inclusive)

• fn window_height_between:

  • &self

  • arg min_px: f32

  • arg max_px: f32

  • -> bool

Returns the current window width in pixels

• fn get_window_width:

  • &self

  • -> f32

Returns the current window height in pixels

• fn get_window_height:

  • &self

  • -> f32

Returns the current window DPI factor

• fn get_dpi_factor:

  • &self

  • -> f32

struct TimerCallback

cb: TimerCallbackType

ctx: OptionRefAny

struct TimerCallbackInfo

callback_info: CallbackInfo

node_id: OptionDomNodeId

frame_start: Instant

call_count: usize

is_about_to_finish: bool

_abi_ref: c_void

_abi_mut: c_void

• constructor create:

  • arg callback_info: CallbackInfo

  • arg node_id: OptionDomNodeId

  • arg frame_start: Instant

  • arg call_count: usize

  • arg is_about_to_finish: bool

  • -> TimerCallbackInfo

• fn get_attached_node_size:

  • &self

  • -> OptionLogicalSize

• fn get_attached_node_position:

  • &self

  • -> OptionLogicalPosition

Re-render ALL image callbacks across all DOMs (applied after callback returns)
This is the most efficient way to update animated GL textures from a timer. Triggers only texture re-rendering - no DOM rebuild or display list resubmission.
# Example

• fn update_all_image_callbacks:

  • &mut self

Trigger re-rendering of a VirtualView (applied after callback returns)
This forces the VirtualView to call its layout callback with reason DomRecreated and submit a new display list to WebRender.

• fn trigger_virtual_view_rerender:

  • &mut self

  • arg dom_id: DomId

  • arg node_id: NodeId

struct TimerCallbackReturn

should_update: Update

should_terminate: TerminateTimer

Creates a new TimerCallbackReturn with the given update and terminate flags.

• constructor create:

  • arg should_update: Update

  • arg should_terminate: TerminateTimer

  • -> TimerCallbackReturn

Timer continues running, no DOM update needed.

• constructor continue_unchanged:

  • -> TimerCallbackReturn

Timer continues running and DOM should be refreshed.

• constructor continue_and_refresh_dom:

  • -> TimerCallbackReturn

Timer should stop, no DOM update needed.

• constructor terminate_unchanged:

  • -> TimerCallbackReturn

Timer should stop and DOM should be refreshed.

• constructor terminate_and_refresh_dom:

  • -> TimerCallbackReturn

struct WriteBackCallback

cb: WriteBackCallbackType

ctx: OptionRefAny

struct ThreadCallback

cb: ThreadCallbackType

ctx: OptionRefAny

struct RefAny

sharing_info: RefCount

instance_id: u64

Creates a new RefAny from a raw pointer wrapper, size, alignment, type_id, type_name, destructor, and optional JSON serialization function pointers

• constructor new_c:

  • arg ptr: GlVoidPtrConst

  • arg len: usize

  • arg align: usize

  • arg type_id: u64

  • arg type_name: String

  • arg destructor: RefAnyDestructorType

  • arg serialize_fn: usize

  • arg deserialize_fn: usize

  • -> RefAny

Returns the internal data pointer. Used by AZ_REFLECT macros for downcasting.

• fn get_data_ptr:

  • &self

  • -> c_void

Returns the type ID of this RefAny

• fn get_type_id:

  • &self

  • -> u64

Returns true if this RefAny is of the given type ID

• fn is_type:

  • &self

  • arg type_id: u64

  • -> bool

Sets the serialization function pointer for JSON export

• fn set_serialize_fn:

  • &mut self

  • arg serialize_fn: usize

Sets the deserialization function pointer for JSON import

• fn set_deserialize_fn:

  • &mut self

  • arg deserialize_fn: usize

Replaces the contents of this RefAny with a new value. This properly destroys the old value and updates all metadata. Since all clones share the same internal data, this change is visible to ALL clones. Returns true if successful, false if there are active borrows.

• fn replace_contents:

  • &mut self

  • arg new_value: RefAny

  • -> bool

Returns true if this RefAny has a serialization function set

• fn can_serialize:

  • &self

  • -> bool

Returns true if this RefAny has a deserialization function set

• fn can_deserialize:

  • &self

  • -> bool

Returns the serialization function pointer (0 if not set)

• fn get_serialize_fn:

  • &self

  • -> usize

Returns the deserialization function pointer (0 if not set)

• fn get_deserialize_fn:

  • &self

  • -> usize

Serialize this RefAny to JSON using its registered serialize function.
Returns Some(Json) on success, or None if serialization is not supported.

• fn serialize_to_json:

  • &self

  • -> OptionJson

struct RefCount

ptr: c_void

run_destructor: bool

Returns true if this RefCount can be shared (no mutable borrows active)

• fn can_be_shared:

  • &self

  • -> bool

Returns true if this RefCount can be mutably shared (no borrows active)

• fn can_be_shared_mut:

  • &self

  • -> bool

Increases the shared reference count

• fn increase_ref:

  • &self

Decreases the shared reference count

• fn decrease_ref:

  • &self

Increases the mutable reference count

• fn increase_refmut:

  • &self

Decreases the mutable reference count

• fn decrease_refmut:

  • &self

Information passed to image rendering callbacks

struct RenderImageCallbackInfo

callback_node_id: DomNodeId

bounds: HidpiAdjustedBounds

gl_context: c_void

image_cache: c_void

system_fonts: c_void

callable_ptr: c_void

_abi_mut: c_void

Returns the bounds of the laid-out node

• fn get_bounds:

  • &self

  • -> HidpiAdjustedBounds

Returns the DOM node ID that the callback is attached to

• fn get_callback_node_id:

  • &self

  • -> DomNodeId

Returns the OpenGL context if available

• fn get_gl_context:

  • &self

  • -> OptionGlContextPtr

Returns the context RefAny for FFI callbacks

• fn get_ctx:

  • &self

  • -> OptionRefAny

struct PenState

position: LogicalPosition

pressure: f32

tilt: PenTilt

in_contact: bool

is_eraser: bool

barrel_button_pressed: bool

device_id: u64

tangential_pressure: f32

barrel_roll_rad: f32

tool_id: u32

struct UndoableOperation has destructor

changeset: TextChangeset

pre_state: NodeStateSnapshot

struct GraphemeClusterId

source_run: u32

start_byte_in_run: u32

struct PenTilt

x_tilt: f32

y_tilt: f32

struct ScrollState

scroll_position: LogicalPosition

struct TextChangeset has destructor

id: ChangesetId

target: DomNodeId

operation: TextOperation

timestamp: Instant

Return value for a VirtualView rendering callback. # Dual Size Model VirtualView callbacks return two size/offset pairs that enable lazy loading and virtualization: ## Actual Content (scroll_size + scroll_offset) The size and position of content that has actually been rendered. This is the content currently present in the returned DOM. Example: A table view might render only 20 visible rows out of 1000 total rows. ## Virtual Content (virtual_scroll_size + virtual_scroll_offset) The size and position of content that the VirtualView pretends to have. This is used for scrollbar sizing and positioning, allowing the scrollbar to represent the full dataset even when only a subset is rendered. Example: The same table might pretend to have all 1000 rows for scrollbar sizing. # Conditional Re-invocation The VirtualView callback will be re-invoked only when necessary to avoid performance overhead: 1. Initial render - First time the VirtualView appears in the layout 2. Parent DOM recreated - The parent DOM was rebuilt from scratch (not just re-laid-out) 3. Window resize (expansion only) - Window grows and VirtualView bounds exceed scroll_size - [OK] Only triggers ONCE per expansion (when bounds become uncovered) - Does NOT trigger when window shrinks (content is clipped, not re-rendered) - Does NOT trigger if expanded area is still within existing scroll_size 4. Scroll near edge - User scrolls within threshold (default 200px) of content edge - [OK] Only triggers ONCE per edge approach (prevents repeated calls) - Flag resets when: scroll moves away from edge, or callback returns expanded content 5. Programmatic scroll - set_scroll_position() scrolls beyond rendered scroll_size - Same constraints as rule #4 (threshold and once-per-edge) ## Window Resize Example text Frame 0: VirtualView bounds = 800x600, scroll_size = 800x600 (perfectly covered) Frame 1: Window resizes to 1000x700 (larger) -> VirtualView bounds = 1000x700 -> Bounds no longer fully covered by scroll_size (800x600) -> [OK] RE-INVOKE callback once Frame 2: Window resizes to 1100x800 (even larger) -> If callback returned scroll_size = 1100x800, fully covered again -> Do NOT re-invoke (content covers new bounds) -> If callback returned scroll_size = 1000x700, not fully covered -> [OK] RE-INVOKE again (new uncovered area) Frame 3: Window resizes to 900x650 (smaller) -> Bounds now smaller than scroll_size -> Do NOT re-invoke (content is just clipped by scrollbars) ## Scroll Near Edge Example text scroll_size = 1000x2000 (width x height) Container = 800x600 Threshold = 200px Current scroll_offset = 0x0 User scrolls to scroll_offset = 0x1500: -> Bottom edge at 1500 + 600 = 2100 -> Within 200px of scroll_size.height (2000) -> Distance from edge: 2100 - 2000 = 100px < 200px -> [OK] RE-INVOKE callback to load more content Callback returns: -> New scroll_size = 1000x4000 (doubled) -> Flag reset (edge no longer near) -> User continues scrolling without re-invoke until near new edge # Optimization: Returning None If the callback determines that no new content is needed (e.g., sufficient content has already been rendered ahead of the scroll position), it can return OptionDom::None for the dom field. This signals the layout engine to keep using the current DOM and only update the scroll bounds. ,ignore fn my_virtual_view_callback(data: &mut MyData, info: &mut VirtualViewCallbackInfo) -> VirtualViewReturn { let current_scroll = info.scroll_offset; // Check if we've already rendered content that covers this scroll position if data.already_rendered_area_covers(current_scroll, info.bounds.size) { return VirtualViewReturn { dom: OptionDom::None, // Keep current DOM scroll_size: data.current_scroll_size, scroll_offset: data.current_scroll_offset, virtual_scroll_size: data.virtual_size, virtual_scroll_offset: LogicalPosition::zero(), }; } // Otherwise, render new content let new_dom = data.render_more_content(...); VirtualViewReturn { dom: OptionDom::Some(new_dom), ... } } # Example: Basic VirtualView ,ignore fn my_virtual_view_callback(data: &mut MyData, info: &mut VirtualViewCallbackInfo) -> VirtualViewReturn { let dom = Dom::body() .with_child(Dom::text("Hello from VirtualView!")); let styled_dom = dom; VirtualViewReturn { // The rendered content dom: OptionDom::Some(styled_dom), // Size of actual rendered content (matches container) scroll_size: info.bounds.size, // Content starts at top-left scroll_offset: LogicalPosition::zero(), // Virtual size same as actual (no virtualization needed) virtual_scroll_size: info.bounds.size, virtual_scroll_offset: LogicalPosition::zero(), } } # Example: Virtualized Table (Lazy Loading) ,ignore struct TableData { total_rows: usize, // 1000 rows in full dataset row_height: f32, // 30px per row visible_rows: Vec<Row>, // Currently rendered rows (e.g., rows 0-29) first_visible_row: usize, // Index of first rendered row } fn table_virtual_view_callback(data: &mut TableData, info: &mut VirtualViewCallbackInfo) -> VirtualViewReturn { let container_height = info.bounds.size.height; let scroll_y = info.scroll_offset.y; // Calculate which rows should be visible based on scroll position let first_row = (scroll_y / data.row_height) as usize; let visible_count = (container_height / data.row_height).ceil() as usize + 2; // +2 for buffer // Fetch and render only the visible rows data.visible_rows = data.fetch_rows(first_row, visible_count); data.first_visible_row = first_row; let dom = Dom::body() .with_children( data.visible_rows.iter().map(|row| { Dom::div() .with_child(Dom::text(row.text.clone())) .with_inline_css_props(css_property_vec![ ("height", format!("{}px", data.row_height)), ]) }).collect() ); VirtualViewReturn { dom: OptionDom::Some(dom), // ACTUAL: Size of the ~30 rendered rows (e.g., 900px tall) scroll_size: LogicalSize::new( info.bounds.size.width, data.visible_rows.len() as f32 * data.row_height, ), // ACTUAL: Where these rows start in virtual space (e.g., y=300 if showing rows 10-30) scroll_offset: LogicalPosition::new( 0.0, first_row as f32 * data.row_height, ), // VIRTUAL: Size if all 1000 rows were rendered (30,000px tall) virtual_scroll_size: LogicalSize::new( info.bounds.size.width, data.total_rows as f32 * data.row_height, ), // VIRTUAL: Usually starts at origin virtual_scroll_offset: LogicalPosition::zero(), } } In this example: - Only 20-30 rows are rendered at a time (~600-900px of DOM nodes) - The scrollbar represents all 1000 rows (30,000px virtual height) - When user scrolls near the bottom of rendered content, callback is re-invoked - New rows are rendered, and scroll_size/scroll_offset are updated - User experiences seamless scrolling through the full dataset # How the Layout Engine Uses These Values ## For Rendering - Uses scroll_size to determine the actual size of the VirtualView's content box - Uses scroll_offset to position the content within the virtual space - Clips rendering to the visible viewport ## For Scrollbars - Uses virtual_scroll_size to calculate scrollbar thumb size and track length - Uses virtual_scroll_offset as the base for scroll position calculations - User sees scrollbar representing full virtual size, not just rendered content ## For Re-invocation Checks - Compares viewport bounds against scroll_size to detect edge proximity - Compares current scroll position against scroll_offset + scroll_size bounds - Triggers callback when user scrolls beyond the rendered content threshold

struct VirtualViewReturn has destructor

The DOM with actual rendered content, or None to keep current DOM. - OptionDom::Some(dom) - Replace current content with this new DOM - OptionDom::None - Keep using the previous DOM, only update scroll bounds Returning None is an optimization when the callback determines that the current content is sufficient (e.g., already rendered ahead of scroll position).

dom: OptionDom

Size of the actual rendered content rectangle. This is the size of the content in the dom field (if Some). It may be smaller than virtual_scroll_size if only a subset of content is rendered (virtualization). Example: For a table showing rows 10-30, this might be 600px tall (20 rows x 30px each).

scroll_size: LogicalSize

Offset of the actual rendered content within the virtual coordinate space. This positions the rendered content within the larger virtual space. For virtualized content, this will be non-zero to indicate where the rendered "window" starts. Example: For a table showing rows 10-30, this might be y=300 (row 10 starts 300px from the top).

scroll_offset: LogicalPosition

Size of the virtual content rectangle (for scrollbar sizing). This is the size the scrollbar will represent. It can be much larger than scroll_size to enable lazy loading and virtualization. Example: For a 1000-row table, this might be 30,000px tall (1000 rows x 30px each), even though only 20 rows are actually rendered.

virtual_scroll_size: LogicalSize

Offset of the virtual content (usually zero). This is typically (0, 0) since the virtual space usually starts at the origin. Advanced use cases might use this for complex virtualization scenarios.

virtual_scroll_offset: LogicalPosition

Creates a new VirtualViewReturn with updated DOM content.
Use this when the callback has rendered new content to display.
# Arguments - dom - The new DOM to render - scroll_size - Size of the actual rendered content - scroll_offset - Position of rendered content in virtual space - virtual_scroll_size - Size for scrollbar representation - virtual_scroll_offset - Usually LogicalPosition::zero()

• constructor with_dom:

  • arg dom: Dom

  • arg scroll_size: LogicalSize

  • arg scroll_offset: LogicalPosition

  • arg virtual_scroll_size: LogicalSize

  • arg virtual_scroll_offset: LogicalPosition

  • -> VirtualViewReturn

Creates a return value that keeps the current DOM unchanged.
Use this when the callback determines that the existing content is sufficient (e.g., already rendered ahead of scroll position). This is an optimization to avoid rebuilding the DOM unnecessarily.
# Arguments - scroll_size - Size of the current rendered content - scroll_offset - Position of current content in virtual space - virtual_scroll_size - Size for scrollbar representation - virtual_scroll_offset - Usually LogicalPosition::zero()

• constructor keep_current:

  • arg scroll_size: LogicalSize

  • arg scroll_offset: LogicalPosition

  • arg virtual_scroll_size: LogicalSize

  • arg virtual_scroll_offset: LogicalPosition

  • -> VirtualViewReturn

The document model, similar to HTML. This is a create-only structure, you don't actually read anything back from it. It's designed for ease of construction.

struct Dom has destructor

The data for the root node of this DOM (or sub-DOM).

root: NodeData

The children of this DOM node.

children: DomVec

Ordered list of CSS stylesheets to apply to this DOM subtree. Stylesheets are applied in push order during the single deferred cascade pass. Later entries override earlier ones (higher cascade priority).

css: CssVec

estimated_total_children: usize

• constructor create_body:

  • -> Dom

Creates a generic block-level container.
Accessibility: Prefer semantic elements like <article>, <section>, <nav> when applicable.

• constructor create_div:

  • -> Dom

• constructor create_br:

  • -> Dom

• constructor create_text:

  • arg value: String

  • -> Dom

• constructor create_image:

  • arg image: ImageRef

  • -> Dom

Creates an icon element that will be resolved by the icon provider.
Accessibility: Icons are resolved to images or font glyphs with automatic aria-label generation. The icon name is used to generate the accessibility label.
The icon resolution happens during the StyledDom creation phase, before layout. The icon provider returns a StyledDom subtree that replaces the icon node.

• constructor create_icon:

  • arg icon_name: String

  • -> Dom

• constructor create_virtual_view:

  • arg data: RefAny

  • arg callback: VirtualViewCallback

  • -> Dom

Creates an empty DOM with a give NodeType. Note: This is a const fn and doesn't allocate, it only allocates once you add at least one child node.

• constructor create_node:

  • arg node_type: NodeType

  • -> Dom

• constructor create_from_data:

  • arg node_data: NodeData

  • -> Dom

Creates a Dom from an already-parsed Xml structure. CSS from <style> tags is attached to the Dom.css field and will be applied during the cascade pass. This is the correct function for layout callbacks that return Dom.

• constructor create_from_parsed_xml:

  • arg xml: Xml

  • -> Dom

Creates the root HTML element.
Accessibility: The <html> element is the root of an HTML document and should have a lang attribute.

• constructor create_html:

  • -> Dom

Creates the document head element.
Accessibility: The <head> contains metadata. Use <title> for page titles.

• constructor create_head:

  • -> Dom

Creates an article element.
Accessibility: Represents self-contained content that could be distributed independently. Screen readers can navigate by articles. Consider adding aria-label for multiple articles.

• constructor create_article:

  • -> Dom

Creates a section element.
Accessibility: Represents a thematic grouping of content with a heading. Should typically have a heading (h1-h6) as a child. Consider aria-labelledby.

• constructor create_section:

  • -> Dom

Creates a navigation element.
Accessibility: Represents navigation links. Screen readers can jump to navigation. Use aria-label to distinguish multiple nav elements (e.g., "Main navigation", "Footer links").

• constructor create_nav:

  • -> Dom

Creates an aside element.
Accessibility: Represents content tangentially related to main content (sidebars, callouts). Screen readers announce this as complementary content.

• constructor create_aside:

  • -> Dom

Creates a header element.
Accessibility: Represents introductory content or navigational aids. Can be used for page headers or section headers.

• constructor create_header:

  • -> Dom

Creates a footer element.
Accessibility: Represents footer for nearest section or page. Typically contains copyright, author info, or related links.

• constructor create_footer:

  • -> Dom

Creates a main content element.
Accessibility: Represents the dominant content. There should be only ONE main per page. Screen readers can jump directly to main content. Do not nest inside article/aside/footer/header/nav.

• constructor create_main:

  • -> Dom

Creates a figure element.
Accessibility: Represents self-contained content like diagrams, photos, code listings. Use with <figcaption> to provide a caption. Screen readers associate caption with figure.

• constructor create_figure:

  • -> Dom

Creates a figure caption element.
Accessibility: Provides a caption for <figure>. Screen readers announce this as the figure description.

• constructor create_figcaption:

  • -> Dom

Creates a details disclosure element with accessibility information.
Use create_details_no_a11y only as a deliberate escape hatch.
Accessibility: Creates a disclosure widget. Screen readers announce expanded/collapsed state. Must contain a <summary> element. Keyboard accessible by default.

• constructor create_details:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a details disclosure element without accessibility information.
Prefer create_details so that screen readers announce the disclosure widget's purpose.

• constructor create_details_no_a11y:

  • -> Dom

Creates an empty summary element for details with accessibility information.
Use create_summary_no_a11y only as a deliberate escape hatch.
Accessibility: The visible heading/label for <details>. Must be the first child of details. Keyboard accessible (Enter/Space to toggle).

• constructor create_summary:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates an empty summary element for details without accessibility information.
Prefer create_summary so that screen readers can announce the disclosure heading.

• constructor create_summary_no_a11y:

  • -> Dom

Creates a summary element with text and accessibility information for details.
Use create_summary_with_text_no_a11y only as a deliberate escape hatch.
Accessibility: The visible heading/label for <details>. Must be the first child of details. Keyboard accessible (Enter/Space to toggle).

• constructor create_summary_with_text:

  • arg text: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a summary element with text without accessibility information.
Prefer create_summary_with_text so that screen readers announce the disclosure heading.

• constructor create_summary_with_text_no_a11y:

  • arg text: String

  • -> Dom

Creates a dialog element with accessibility information.
Use create_dialog_no_a11y only as a deliberate escape hatch.
Accessibility: Represents a modal or non-modal dialog. When opened as modal, focus is trapped. Use aria-label or aria-labelledby. Escape key should close modal dialogs.

• constructor create_dialog:

  • arg aria: DialogAriaInfo

  • -> Dom

Creates a dialog element without accessibility information.
Prefer create_dialog so that the dialog's modality and purpose are announced.

• constructor create_dialog_no_a11y:

  • -> Dom

Creates a paragraph element.
Accessibility: Paragraphs provide semantic structure for screen readers.

• constructor create_p:

  • -> Dom

Creates an empty heading level 1 element.
Accessibility: Use h1 for the main page title. There should typically be only one h1 per page.

• constructor create_h1:

  • -> Dom

Creates a heading level 1 element with text.
Accessibility: Use h1 for the main page title. There should typically be only one h1 per page.
Parameters: - text: Heading text

• constructor create_h1_with_text:

  • arg text: String

  • -> Dom

Creates an empty heading level 2 element.
Accessibility: Use h2 for major section headings under h1.

• constructor create_h2:

  • -> Dom

Creates a heading level 2 element with text.
Accessibility: Use h2 for major section headings under h1.
Parameters: - text: Heading text

• constructor create_h2_with_text:

  • arg text: String

  • -> Dom

Creates an empty heading level 3 element.
Accessibility: Use h3 for subsections under h2.

• constructor create_h3:

  • -> Dom

Creates a heading level 3 element with text.
Accessibility: Use h3 for subsections under h2.
Parameters: - text: Heading text

• constructor create_h3_with_text:

  • arg text: String

  • -> Dom

Creates an empty heading level 4 element.

• constructor create_h4:

  • -> Dom

Creates a heading level 4 element with text.
Parameters: - text: Heading text

• constructor create_h4_with_text:

  • arg text: String

  • -> Dom

Creates an empty heading level 5 element.

• constructor create_h5:

  • -> Dom

Creates a heading level 5 element with text.
Parameters: - text: Heading text

• constructor create_h5_with_text:

  • arg text: String

  • -> Dom

Creates an empty heading level 6 element.

• constructor create_h6:

  • -> Dom

Creates a heading level 6 element with text.
Parameters: - text: Heading text

• constructor create_h6_with_text:

  • arg text: String

  • -> Dom

Creates an empty generic inline container (span).
Accessibility: Prefer semantic elements like strong, em, code, etc. when applicable.

• constructor create_span:

  • -> Dom

Creates a generic inline container (span) with text.
Accessibility: Prefer semantic elements like strong, em, code, etc. when applicable.
Parameters: - text: Span content

• constructor create_span_with_text:

  • arg text: String

  • -> Dom

Creates an empty strong importance element.
Accessibility: Use strong instead of b for semantic meaning.

• constructor create_strong:

  • -> Dom

Creates a strongly emphasized text element with text (strong importance).
Accessibility: Use strong instead of b for semantic meaning. Screen readers can convey the importance. Use for text that has strong importance, seriousness, or urgency.
Parameters: - text: Text to emphasize

• constructor create_strong_with_text:

  • arg text: String

  • -> Dom

Creates an empty emphasis element (stress emphasis).
Accessibility: Use em instead of i for semantic meaning.

• constructor create_em:

  • -> Dom

Creates an emphasized text element with text (stress emphasis).
Accessibility: Use em instead of i for semantic meaning. Screen readers can convey the emphasis. Use for text that has stress emphasis.
Parameters: - text: Text to emphasize

• constructor create_em_with_text:

  • arg text: String

  • -> Dom

Creates an empty code element.
Accessibility: Represents a fragment of computer code.

• constructor create_code:

  • -> Dom

Creates a code/computer code element with text.
Accessibility: Represents a fragment of computer code. Screen readers can identify this as code content.
Parameters: - code: Code content

• constructor create_code_with_text:

  • arg code: String

  • -> Dom

Creates an empty preformatted text element.
Accessibility: Preserves whitespace and line breaks.

• constructor create_pre:

  • -> Dom

Creates a preformatted text element with text.
Accessibility: Preserves whitespace and line breaks. Useful for code blocks or ASCII art. Screen readers will read the content as-is.
Parameters: - text: Preformatted content

• constructor create_pre_with_text:

  • arg text: String

  • -> Dom

Creates an empty blockquote element.
Accessibility: Represents a section quoted from another source.

• constructor create_blockquote:

  • -> Dom

Creates a blockquote element with text.
Accessibility: Represents a section quoted from another source. Screen readers can identify quoted content. Consider adding a cite attribute.
Parameters: - text: Quote content

• constructor create_blockquote_with_text:

  • arg text: String

  • -> Dom

Creates an empty citation element.
Accessibility: Represents a reference to a creative work.

• constructor create_cite:

  • -> Dom

Creates a citation element with text.
Accessibility: Represents a reference to a creative work. Screen readers can identify citations.
Parameters: - text: Citation text

• constructor create_cite_with_text:

  • arg text: String

  • -> Dom

Creates an empty abbreviation element.
Accessibility: Represents an abbreviation or acronym. Use with a title attribute to provide the full expansion for screen readers.

• constructor create_abbr:

  • -> Dom

Creates an abbreviation element with abbreviated text and a title expansion.
Accessibility: Represents an abbreviation or acronym. The title attribute provides the full expansion for screen readers.
Parameters: - abbr_text: Abbreviated text - title: Full expansion

• constructor create_abbr_with_title:

  • arg abbr_text: String

  • arg title: String

  • -> Dom

Creates an empty keyboard input element.
Accessibility: Represents keyboard input or key combinations.

• constructor create_kbd:

  • -> Dom

Creates a keyboard input element with text.
Accessibility: Represents keyboard input or key combinations. Screen readers can identify keyboard instructions.
Parameters: - text: Keyboard instruction

• constructor create_kbd_with_text:

  • arg text: String

  • -> Dom

Creates an empty sample output element.
Accessibility: Represents sample output from a program or computing system.

• constructor create_samp:

  • -> Dom

Creates a sample output element with text.
Accessibility: Represents sample output from a program or computing system.
Parameters: - text: Sample text

• constructor create_samp_with_text:

  • arg text: String

  • -> Dom

Creates an empty variable element.
Accessibility: Represents a variable in mathematical expressions or programming.

• constructor create_var:

  • -> Dom

Creates a variable element with text.
Accessibility: Represents a variable in mathematical expressions or programming.
Parameters: - text: Variable name

• constructor create_var_with_text:

  • arg text: String

  • -> Dom

Creates an empty subscript element.

• constructor create_sub:

  • -> Dom

Creates a subscript element with text.
Accessibility: Screen readers may announce subscript formatting.
Parameters: - text: Subscript content

• constructor create_sub_with_text:

  • arg text: String

  • -> Dom

Creates an empty superscript element.

• constructor create_sup:

  • -> Dom

Creates a superscript element with text.
Accessibility: Screen readers may announce superscript formatting.
Parameters: - text: Superscript content

• constructor create_sup_with_text:

  • arg text: String

  • -> Dom

Creates an empty underline element.

• constructor create_u:

  • -> Dom

Creates an underline text element with text.
Accessibility: Screen readers typically don't announce underline formatting. Use semantic elements when possible (e.g., <em> for emphasis).

• constructor create_u_with_text:

  • arg text: String

  • -> Dom

Creates an empty strikethrough element.

• constructor create_s:

  • -> Dom

Creates a strikethrough text element with text.
Accessibility: Represents text that is no longer accurate or relevant. Consider using <del> for deleted content with datetime attribute.

• constructor create_s_with_text:

  • arg text: String

  • -> Dom

Creates an empty mark element.

• constructor create_mark:

  • -> Dom

Creates a marked/highlighted text element with text.
Accessibility: Represents text marked for reference or notation purposes. Screen readers may announce this as "highlighted".

• constructor create_mark_with_text:

  • arg text: String

  • -> Dom

Creates an empty deleted text element.

• constructor create_del:

  • -> Dom

Creates a deleted text element with text.
Accessibility: Represents deleted content in document edits. Use with datetime and cite attributes for edit tracking.

• constructor create_del_with_text:

  • arg text: String

  • -> Dom

Creates an empty inserted text element.

• constructor create_ins:

  • -> Dom

Creates an inserted text element with text.
Accessibility: Represents inserted content in document edits. Use with datetime and cite attributes for edit tracking.

• constructor create_ins_with_text:

  • arg text: String

  • -> Dom

Creates an empty definition element.

• constructor create_dfn:

  • -> Dom

Creates a definition element with text.
Accessibility: Represents the defining instance of a term. Often used within a definition list or with <abbr>.

• constructor create_dfn_with_text:

  • arg text: String

  • -> Dom

Creates a time element.
Accessibility: Represents a specific time or date. Use datetime attribute for machine-readable format.
Parameters: - text: Human-readable time/date - datetime: Optional machine-readable datetime

• constructor create_time:

  • arg text: String

  • arg datetime: OptionString

  • -> Dom

Creates an empty bi-directional override element.
Accessibility: Overrides text direction. Use dir attribute (ltr/rtl).

• constructor create_bdo:

  • -> Dom

Creates a bi-directional override element with text.
Accessibility: Overrides text direction. Use dir attribute (ltr/rtl).

• constructor create_bdo_with_text:

  • arg text: String

  • -> Dom

Creates an anchor (hyperlink) with href, visible text, and accessibility information.
Use create_a_no_a11y only as a deliberate escape hatch (for example, image-only links whose accessible name comes from an <img alt>).
Parameters: - href: Link destination URL - text: Visible link text - aria: Accessibility information (expanded description, etc.)

• constructor create_a:

  • arg href: String

  • arg text: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates an anchor/hyperlink element without accessibility information.
Prefer create_a so that screen readers get a meaningful label.
Parameters: - href: Link destination URL - label: Link text (pass None for image-only links with alt text)

• constructor create_a_no_a11y:

  • arg href: String

  • arg label: OptionString

  • -> Dom

Creates a button element with text content and accessibility information.
Use create_button_no_a11y only as a deliberate escape hatch.
Parameters: - text: Button label text - aria: Accessibility information (role, description, etc.)

• constructor create_button:

  • arg text: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a button element without accessibility information.
Prefer create_button so that the element has a meaningful accessible name for screen readers.
Parameters: - text: Button label text

• constructor create_button_no_a11y:

  • arg text: String

  • -> Dom

Creates a label element for form controls with accessibility information.
Use create_label_no_a11y only as a deliberate escape hatch.
Parameters: - for_id: ID of the associated form control - text: Label text - aria: Accessibility information (description, etc.)

• constructor create_label:

  • arg for_id: String

  • arg text: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a label element for form controls without accessibility information.
Prefer create_label so that screen readers get a descriptive label.
Parameters: - for_id: ID of the associated form control - text: Label text

• constructor create_label_no_a11y:

  • arg for_id: String

  • arg text: String

  • -> Dom

Creates an input element with type, name, and accessibility information.
Use create_input_no_a11y only as a deliberate escape hatch.
Parameters: - input_type: Input type (text, password, email, etc.) - name: Form field name - label: Accessibility label - aria: Accessibility information (description, etc.)

• constructor create_input:

  • arg input_type: String

  • arg name: String

  • arg label: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates an input element without accessibility information.
Prefer create_input so that screen readers get a descriptive label beyond the HTML aria-label attribute.
Parameters: - input_type: Input type (text, password, email, etc.) - name: Form field name - label: Accessibility label (required)

• constructor create_input_no_a11y:

  • arg input_type: String

  • arg name: String

  • arg label: String

  • -> Dom

Creates a textarea element with name and accessibility information.
Use create_textarea_no_a11y only as a deliberate escape hatch.
Parameters: - name: Form field name - label: Accessibility label - aria: Accessibility information (description, etc.)

• constructor create_textarea:

  • arg name: String

  • arg label: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a textarea element without accessibility information.
Prefer create_textarea so that screen readers get an accurate description of the control.
Parameters: - name: Form field name - label: Accessibility label (required)

• constructor create_textarea_no_a11y:

  • arg name: String

  • arg label: String

  • -> Dom

Creates a select dropdown with name and accessibility information.
Use create_select_no_a11y only as a deliberate escape hatch.
Parameters: - name: Form field name - label: Accessibility label - aria: Accessibility information (description, etc.)

• constructor create_select:

  • arg name: String

  • arg label: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a select dropdown without accessibility information.
Prefer create_select so that screen readers announce the control appropriately.
Parameters: - name: Form field name - label: Accessibility label (required)

• constructor create_select_no_a11y:

  • arg name: String

  • arg label: String

  • -> Dom

Creates an option element for select dropdowns with accessibility information.
Use create_option_no_a11y only as a deliberate escape hatch.
Parameters: - value: Option value - text: Display text - aria: Accessibility information (description, etc.)

• constructor create_option:

  • arg value: String

  • arg text: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates an option element for select dropdowns without accessibility information.
Prefer create_option so that screen readers can announce a description.
Parameters: - value: Option value - text: Display text

• constructor create_option_no_a11y:

  • arg value: String

  • arg text: String

  • -> Dom

Creates an unordered list element.
Accessibility: Screen readers announce lists and item counts, helping users understand content structure.

• constructor create_ul:

  • -> Dom

Creates an ordered list element.
Accessibility: Screen readers announce lists and item counts, helping users understand content structure and numbering.

• constructor create_ol:

  • -> Dom

Creates a list item element.
Accessibility: Must be a child of ul, ol, or menu. Screen readers announce list item position (e.g., "2 of 5").

• constructor create_li:

  • -> Dom

Creates a table element with a caption and accessibility information.
Use create_table_no_a11y only as a deliberate escape hatch.
Parameters: - caption: Visible caption text for the table - aria: Accessibility information describing table purpose

• constructor create_table:

  • arg caption: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a table element without accessibility information.
Prefer create_table so that screen readers can announce the table's purpose alongside its caption.

• constructor create_table_no_a11y:

  • -> Dom

Creates a table caption element.
Accessibility: Describes the purpose of the table. Screen readers announce this first.

• constructor create_caption:

  • -> Dom

Creates a table header element.
Accessibility: Groups header rows. Screen readers can navigate table structure.

• constructor create_thead:

  • -> Dom

Creates a table body element.
Accessibility: Groups body rows. Screen readers can navigate table structure.

• constructor create_tbody:

  • -> Dom

Creates a table footer element.
Accessibility: Groups footer rows. Screen readers can navigate table structure.

• constructor create_tfoot:

  • -> Dom

Creates a table row element.

• constructor create_tr:

  • -> Dom

Creates a table header cell element.
Accessibility: Use scope attribute ("col" or "row") to associate headers with data cells. Screen readers use this to announce cell context.

• constructor create_th:

  • -> Dom

Creates a table data cell element.

• constructor create_td:

  • -> Dom

Creates a form element with accessibility information.
Use create_form_no_a11y only as a deliberate escape hatch.
Accessibility: Group related form controls with fieldset and legend. Provide clear labels for all inputs. Consider aria-describedby for instructions.

• constructor create_form:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a form element without accessibility information.
Prefer create_form so that screen readers can announce the form's purpose.

• constructor create_form_no_a11y:

  • -> Dom

Creates a fieldset element with accessibility information.
Use create_fieldset_no_a11y only as a deliberate escape hatch.
Accessibility: Groups related form controls. Always include a legend as the first child to describe the group. Screen readers announce the legend when entering the fieldset.

• constructor create_fieldset:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a fieldset element for grouping form controls without accessibility info.
Prefer create_fieldset so that screen readers can announce the group's purpose.

• constructor create_fieldset_no_a11y:

  • -> Dom

Creates a legend element with accessibility information.
Use create_legend_no_a11y only as a deliberate escape hatch.
Accessibility: Describes the purpose of a fieldset. Must be the first child of a fieldset. Screen readers announce this when entering the fieldset.

• constructor create_legend:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a legend element without accessibility information.
Prefer create_legend so that the legend's accessible name is explicit.

• constructor create_legend_no_a11y:

  • -> Dom

Creates a horizontal rule element.
Accessibility: Represents a thematic break. Screen readers may announce this as a separator. Consider using CSS borders for purely decorative lines.

• constructor create_hr:

  • -> Dom

Creates an address element.
Accessibility: Represents contact information. Screen readers identify this as address content.

• constructor create_address:

  • -> Dom

Creates a definition list element.
Accessibility: Screen readers announce definition lists and their structure.

• constructor create_dl:

  • -> Dom

Creates a definition term element.
Accessibility: Must be a child of dl. Represents the term being defined.

• constructor create_dt:

  • -> Dom

Creates a definition description element.
Accessibility: Must be a child of dl. Provides the definition for the term.

• constructor create_dd:

  • -> Dom

Creates a table column group element.

• constructor create_colgroup:

  • -> Dom

Creates a table column element.

• constructor create_col:

  • arg span: i32

  • -> Dom

Creates an optgroup element for grouping select options with accessibility information.
Use create_optgroup_no_a11y only as a deliberate escape hatch.
Parameters: - label: Label for the option group (visible) - aria: Additional accessibility information (description, etc.)

• constructor create_optgroup:

  • arg label: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates an optgroup element for grouping select options without accessibility info.
Prefer create_optgroup so that screen readers can announce the group's purpose.
Parameters: - label: Label for the option group

• constructor create_optgroup_no_a11y:

  • arg label: String

  • -> Dom

Creates a quotation element.
Accessibility: Represents an inline quotation.

• constructor create_q:

  • -> Dom

Creates an empty acronym element.
Note: Deprecated in HTML5. Consider using create_abbr() instead.

• constructor create_acronym:

  • -> Dom

Creates an acronym element with text.
Note: Deprecated in HTML5. Consider using create_abbr_with_title() instead.

• constructor create_acronym_with_text:

  • arg text: String

  • -> Dom

Creates a menu element with accessibility information.
Use create_menu_no_a11y only as a deliberate escape hatch.
Accessibility: Represents a list of commands. Similar to <ul> but semantic for toolbars/menus.

• constructor create_menu:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a menu element without accessibility information.
Prefer create_menu so that the menu's purpose is announced.

• constructor create_menu_no_a11y:

  • -> Dom

Creates an empty menu item element with accessibility information.
Use create_menuitem_no_a11y only as a deliberate escape hatch.
Accessibility: Represents a command in a menu. Use with appropriate role/aria attributes.

• constructor create_menuitem:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates an empty menu item element without accessibility information.
Prefer create_menuitem so that the menu item's purpose is announced.

• constructor create_menuitem_no_a11y:

  • -> Dom

Creates a menu item element with text and accessibility information.
Use create_menuitem_with_text_no_a11y only as a deliberate escape hatch.
Accessibility: Represents a command in a menu. Use with appropriate role/aria attributes.

• constructor create_menuitem_with_text:

  • arg text: String

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a menu item element with text but without accessibility information.
Prefer create_menuitem_with_text so that screen readers get a distinct accessible name.

• constructor create_menuitem_with_text_no_a11y:

  • arg text: String

  • -> Dom

Creates an output element with accessibility information.
Use create_output_no_a11y only as a deliberate escape hatch.
Accessibility: Represents the result of a calculation or user action. Use for attribute to associate with input elements. Screen readers announce updates.

• constructor create_output:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates an output element without accessibility information.
Prefer create_output so that screen readers can announce the computed value's purpose.

• constructor create_output_no_a11y:

  • -> Dom

Creates a progress indicator element with accessibility information.
Use create_progress_no_a11y only as a deliberate escape hatch.
Accessibility: Represents task progress. Screen readers announce progress percentage. The aria value carries the label, current value, max, and an indeterminate flag for spinners with no known endpoint.

• constructor create_progress:

  • arg aria: ProgressAriaInfo

  • -> Dom

Creates a progress indicator element without accessibility information.
Prefer create_progress so that the task being measured is announced.
Parameters: - value: Current progress value - max: Maximum value

• constructor create_progress_no_a11y:

  • arg value: f32

  • arg max: f32

  • -> Dom

Creates a meter gauge element with accessibility information.
Use create_meter_no_a11y only as a deliberate escape hatch.
Accessibility: Represents a scalar measurement within a known range. Screen readers announce the measurement. The aria value carries the label plus value/min/max/low/high/optimum metadata.

• constructor create_meter:

  • arg aria: MeterAriaInfo

  • -> Dom

Creates a meter gauge element without accessibility information.
Prefer create_meter so that the measurement's purpose is announced.
Parameters: - value: Current meter value - min: Minimum value - max: Maximum value

• constructor create_meter_no_a11y:

  • arg value: f32

  • arg min: f32

  • arg max: f32

  • -> Dom

Creates a datalist element for input suggestions with accessibility information.
Use create_datalist_no_a11y only as a deliberate escape hatch.
Accessibility: Provides autocomplete options for inputs. Associate with input using list attribute. Screen readers announce available options.

• constructor create_datalist:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a datalist element for input suggestions without accessibility information.
Prefer create_datalist so that the suggestion list's purpose is announced.

• constructor create_datalist_no_a11y:

  • -> Dom

Creates a canvas element for graphics with accessibility information.
Use create_canvas_no_a11y only as a deliberate escape hatch.
Accessibility: Canvas content is not accessible by default. Always provide fallback content as children and/or detailed aria-label. Consider using SVG for accessible graphics when possible.

• constructor create_canvas:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a canvas element for graphics without accessibility information.
Prefer create_canvas so that the canvas's purpose is announced; canvas content is otherwise opaque to assistive technologies.

• constructor create_canvas_no_a11y:

  • -> Dom

Creates an object element for embedded content.
Accessibility: Provide fallback content as children. Use aria-label to describe content.

• constructor create_object:

  • -> Dom

Creates a param element for object parameters.
Parameters: - name: Parameter name - value: Parameter value

• constructor create_param:

  • arg name: String

  • arg value: String

  • -> Dom

Creates an embed element.
Accessibility: Provide alternative content or link. Use aria-label to describe embedded content.

• constructor create_embed:

  • -> Dom

Creates an audio element with accessibility information.
Use create_audio_no_a11y only as a deliberate escape hatch.
Accessibility: Always provide controls. Use <track> for captions/subtitles. Provide fallback text for unsupported browsers.

• constructor create_audio:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates an audio element without accessibility information.
Prefer create_audio so that screen readers announce the audio's purpose.

• constructor create_audio_no_a11y:

  • -> Dom

Creates a video element with accessibility information.
Use create_video_no_a11y only as a deliberate escape hatch.
Accessibility: Always provide controls. Use <track> for captions/subtitles/descriptions. Provide fallback text. Consider providing transcript.

• constructor create_video:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates a video element without accessibility information.
Prefer create_video so that screen readers announce the video's purpose.

• constructor create_video_no_a11y:

  • -> Dom

Creates a source element for media.
Parameters: - src: Media source URL - media_type: MIME type (e.g., "video/mp4", "audio/ogg")

• constructor create_source:

  • arg src: String

  • arg media_type: String

  • -> Dom

Creates a track element for media captions/subtitles.
Accessibility: Essential for deaf/hard-of-hearing users and non-native speakers. Use kind (subtitles/captions/descriptions), srclang, and label attributes.
Parameters: - src: Track file URL (WebVTT format) - kind: Track kind ("subtitles", "captions", "descriptions", "chapters", "metadata")

• constructor create_track:

  • arg src: String

  • arg kind: String

  • -> Dom

Creates a map element for image maps.
Accessibility: Provide text alternatives. Ensure all areas have alt text.

• constructor create_map:

  • -> Dom

Creates an area element for image map regions with accessibility information.
Use create_area_no_a11y only as a deliberate escape hatch.
Accessibility: Always provide alt text describing the region/link purpose. Keyboard users should be able to navigate areas.

• constructor create_area:

  • arg aria: SmallAriaInfo

  • -> Dom

Creates an area element for image map regions without accessibility information.
Prefer create_area so that screen readers can announce the region's purpose.

• constructor create_area_no_a11y:

  • -> Dom

Creates an empty title element for document title.
Accessibility: Required for all pages. Screen readers announce this first.

• constructor create_title:

  • -> Dom

Creates a title element for document title with text.
Accessibility: Required for all pages. Screen readers announce this first. Should be unique and descriptive. Keep under 60 characters.

• constructor create_title_with_text:

  • arg text: String

  • -> Dom

Creates a meta element.
Accessibility: Use for charset, viewport, description. Crucial for proper text display.

• constructor create_meta:

  • -> Dom

Creates a link element for external resources.
Accessibility: Use for stylesheets, icons, alternate versions. Provide meaningful title attribute for alternate stylesheets.

• constructor create_link:

  • -> Dom

Creates a script element.
Accessibility: Ensure scripted content is accessible. Provide noscript fallbacks for critical functionality.

• constructor create_script:

  • -> Dom

Creates an empty style element for embedded CSS.
Note: In Azul, use .with_component_css() instead for styling. This creates a <style> HTML element for embedded stylesheets.

• constructor create_style:

  • -> Dom

Creates a style element for embedded CSS with the given stylesheet text.
Note: In Azul, use .with_component_css() instead for styling. This creates a <style> HTML element for embedded stylesheets.

• constructor create_style_with_text:

  • arg text: String

  • -> Dom

Creates a base element for document base URL.
Parameters: - href: Base URL for relative URLs in the document

• constructor create_base:

  • arg href: String

  • -> Dom

Creates an empty bold element.
Accessibility: Prefer <strong> for semantic emphasis. <b> is purely stylistic.

• constructor create_b:

  • -> Dom

Creates a bold element with text.
Accessibility: Prefer <strong> for semantic emphasis. <b> is purely stylistic.
Parameters: - text: Bold text content

• constructor create_b_with_text:

  • arg text: String

  • -> Dom

Creates an empty italic element.
Accessibility: Prefer <em> for stress emphasis. <i> is purely stylistic.

• constructor create_i:

  • -> Dom

Creates an italic element with text.
Accessibility: Prefer <em> for stress emphasis. <i> is purely stylistic.
Parameters: - text: Italic text content

• constructor create_i_with_text:

  • arg text: String

  • -> Dom

Creates an empty small text element.
Accessibility: Represents side-comments and small print like copyright/legal text.

• constructor create_small:

  • -> Dom

Creates a small text element with text.
Parameters: - text: Small text content

• constructor create_small_with_text:

  • arg text: String

  • -> Dom

Creates an empty <big> element.
Note: Deprecated in HTML5. Prefer CSS font-size.

• constructor create_big:

  • -> Dom

Creates a <big> element with text.
Note: Deprecated in HTML5. Prefer CSS font-size.

• constructor create_big_with_text:

  • arg text: String

  • -> Dom

Creates an empty bi-directional isolate element.
Accessibility: Used to isolate text whose direction is unknown, keeping it from affecting surrounding bidi layout.

• constructor create_bdi:

  • -> Dom

Creates a bi-directional isolate element with text.
Accessibility: Used to isolate text whose direction is unknown, keeping it from affecting surrounding bidi layout.

• constructor create_bdi_with_text:

  • arg text: String

  • -> Dom

Creates an empty word break opportunity element.
Note: <wbr> is a self-closing element that suggests a line-break opportunity. It does not take text content.

• constructor create_wbr:

  • -> Dom

Creates an empty ruby annotation element.
Accessibility: Used for East Asian typography to provide pronunciation/translation annotations. Wraps <rt>/<rp> children.

• constructor create_ruby:

  • -> Dom

Creates an empty ruby text element.
Accessibility: Pronunciation/translation annotation inside <ruby>.

• constructor create_rt:

  • -> Dom

Creates a ruby text element with text.
Parameters: - text: Ruby annotation content

• constructor create_rt_with_text:

  • arg text: String

  • -> Dom

Creates an empty ruby text container element.
Accessibility: Container for ruby text annotations.

• constructor create_rtc:

  • -> Dom

Creates an empty ruby fallback parenthesis element.
Accessibility: Provides parentheses around <rt> for browsers without ruby support.

• constructor create_rp:

  • -> Dom

Creates a ruby fallback parenthesis element with text.
Parameters: - text: Parenthesis text (typically "(" or ")")

• constructor create_rp_with_text:

  • arg text: String

  • -> Dom

Creates a <data> element binding a machine-readable value to its content.
Parameters: - value: Machine-readable value for the value attribute.

• constructor create_data:

  • arg value: String

  • -> Dom

Creates a <data> element with both a machine-readable value and visible text.
Parameters: - value: Machine-readable value for the value attribute. - text: Human-readable text content.

• constructor create_data_with_text:

  • arg value: String

  • arg text: String

  • -> Dom

Creates an empty directory list element.
Note: Deprecated in HTML5. Use <ul> instead.

• constructor create_dir:

  • -> Dom

Creates an empty SVG container element.
Accessibility: Provide aria-label or <title> child for assistive tech.

• constructor create_svg:

  • -> Dom

Creates a table header cell with scope.
Parameters: - scope: "col", "row", "colgroup", or "rowgroup" - text: Header text
Accessibility: The scope attribute is crucial for associating headers with data cells.

• constructor create_th_with_scope:

  • arg scope: String

  • arg text: String

  • -> Dom

Creates a table data cell with text.
Parameters: - text: Cell content

• constructor create_td_with_text:

  • arg text: String

  • -> Dom

Creates a table header cell with text.
Parameters: - text: Header text

• constructor create_th_with_text:

  • arg text: String

  • -> Dom

Creates a list item with text.
Parameters: - text: List item content

• constructor create_li_with_text:

  • arg text: String

  • -> Dom

Creates a paragraph with text.
Parameters: - text: Paragraph content

• constructor create_p_with_text:

  • arg text: String

  • -> Dom

Creates an invisible NodeType::GeolocationProbe node that signals "this subtree needs the user's location". Lays out as zero-size and is skipped in the display list - the framework scans for it at end-of-layout and starts / stops the native CLLocationManager / LocationManager / geoclue subscription. See SUPER_PLAN_2.md section 1.5.

• constructor create_geolocation_probe:

  • arg config: GeolocationProbeConfig

  • -> Dom