Struct FocusManager 

pub struct FocusManager {
    pub focused_node: Option<DomNodeId>,
    pub pending_focus_request: Option<FocusTarget>,
    pub cursor_needs_initialization: bool,
    pub pending_contenteditable_focus: Option<PendingContentEditableFocus>,
}

Manager for keyboard focus and tab navigation

Note: Text cursor management is now handled by the separate CursorManager.

The FocusManager only tracks which node has focus, while CursorManager tracks the cursor position within that node (if it’s contenteditable).

W3C Focus/Selection Model

The W3C model maintains a strict separation between keyboard focus and selection:

1. Focus lands on the contenteditable container (document.activeElement)
2. Selection/Cursor is placed in a descendant text node (Selection.focusNode)

This separation requires a “flag and defer” pattern:

• During focus event: Set cursor_needs_initialization = true
• After layout pass: Call finalize_pending_focus_changes() to actually initialize the cursor

This is necessary because cursor positioning requires text layout information, which isn’t available during the focus event handling phase.

Fields

focused_node: Option<DomNodeId>

Currently focused node (if any)

pending_focus_request: Option<FocusTarget>

Pending focus request from callback

cursor_needs_initialization: bool

Flag indicating that cursor initialization is pending (set during focus, consumed after layout)

pending_contenteditable_focus: Option<PendingContentEditableFocus>

Information about the pending contenteditable focus

Implementations

impl FocusManager

pub fn new() -> Self

Create a new focus manager

pub fn get_focused_node(&self) -> Option<&DomNodeId>

Get the currently focused node

pub fn set_focused_node(&mut self, node: Option<DomNodeId>)

Set the focused node directly (used by event system)

Note: Cursor initialization/clearing is now handled by CursorManager. The event system should check if the newly focused node is contenteditable and call CursorManager::initialize_cursor_at_end() if needed.

pub fn request_focus_change(&mut self, target: FocusTarget)

Request a focus change (to be processed by event system)

pub fn take_focus_request(&mut self) -> Option<FocusTarget>

Take the pending focus request (one-shot)

pub fn clear_focus(&mut self)

Clear focus

pub fn has_focus(&self, node: &DomNodeId) -> bool

Check if a specific node has focus

pub fn set_pending_contenteditable_focus( &mut self, dom_id: DomId, container_node_id: NodeId, text_node_id: NodeId, )

Mark that cursor initialization is needed for a contenteditable element.

This is called during focus event handling. The actual cursor initialization happens later in finalize_pending_focus_changes() after layout is complete.

W3C Conformance

In the W3C model, when focus lands on a contenteditable element:

1. The focus event fires on the container element
2. The browser’s editing engine modifies the Selection to place a caret
3. The Selection’s anchorNode/focusNode point to the child text node

Since we need layout information to position the cursor, we defer step 2+3.

pub fn clear_pending_contenteditable_focus(&mut self)

Clear the pending contenteditable focus (when focus moves away or is cleared).

pub fn take_pending_contenteditable_focus( &mut self, ) -> Option<PendingContentEditableFocus>

Take the pending contenteditable focus (consumes the flag).

Returns Some(info) if cursor initialization is pending, None otherwise. After calling this, cursor_needs_initialization is set to false.

pub fn needs_cursor_initialization(&self) -> bool

Check if cursor initialization is pending.

Trait Implementations

impl Clone for FocusManager

fn clone(&self) -> FocusManager

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FocusManager

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

Formats the value using the given formatter.

impl Default for FocusManager

fn default() -> Self

Returns the “default value” for a type.

impl FocusManagerQuery for FocusManager

fn get_focused_node_id(&self) -> Option<DomNodeId>

Get the currently focused node ID

impl PartialEq for FocusManager

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

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

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

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

impl StructuralPartialEq for FocusManager