Struct CursorManager 

pub struct CursorManager {
    pub cursor: Option<TextCursor>,
    pub cursor_location: Option<CursorLocation>,
    pub is_visible: bool,
    pub last_input_time: Option<Instant>,
    pub blink_timer_active: bool,
}

Manager for text cursor position and rendering

Fields

cursor: Option<TextCursor>

Current cursor position (if any)

cursor_location: Option<CursorLocation>

DOM and node where the cursor is located

is_visible: bool

Whether the cursor is currently visible (toggled by blink timer)

last_input_time: Option<Instant>

Timestamp of the last user input event (keyboard, mouse click in text) Used to determine whether to blink or stay solid while typing

blink_timer_active: bool

Whether the cursor blink timer is currently active

Implementations

impl CursorManager

pub fn new() -> Self

Create a new cursor manager with no cursor

pub fn get_cursor(&self) -> Option<&TextCursor>

Get the current cursor position

pub fn get_cursor_location(&self) -> Option<&CursorLocation>

Get the current cursor location

pub fn set_cursor( &mut self, cursor: Option<TextCursor>, location: Option<CursorLocation>, )

Set the cursor position manually

This is used for programmatic cursor positioning. For automatic initialization when focusing a contenteditable element, use initialize_cursor_at_end().

pub fn set_cursor_with_time( &mut self, cursor: Option<TextCursor>, location: Option<CursorLocation>, now: Instant, )

Set the cursor position with timestamp for blink reset

pub fn clear(&mut self)

Clear the cursor

This is automatically called when focus moves to a non-editable node or when focus is cleared entirely.

pub fn has_cursor(&self) -> bool

Check if there is an active cursor

pub fn should_draw_cursor(&self) -> bool

Check if the cursor should be drawn (has cursor AND is visible)

pub fn reset_blink_on_input(&mut self, now: Instant)

Reset the blink state on user input

This makes the cursor visible and records the input time. The blink timer will keep the cursor visible until CURSOR_BLINK_INTERVAL_MS has passed since this time.

pub fn toggle_visibility(&mut self) -> bool

Toggle cursor visibility (called by blink timer)

Returns the new visibility state.

pub fn set_visibility(&mut self, visible: bool)

Set cursor visibility directly

pub fn should_blink(&self, now: &Instant) -> bool

Check if enough time has passed since last input to start blinking

Returns true if the cursor should blink (toggle visibility), false if it should stay solid (user is actively typing).

pub fn set_blink_timer_active(&mut self, active: bool)

Mark the blink timer as active

pub fn is_blink_timer_active(&self) -> bool

Check if the blink timer is active

pub fn initialize_cursor_at_end( &mut self, dom_id: DomId, node_id: NodeId, text_layout: Option<&Arc<UnifiedLayout>>, ) -> bool

Initialize cursor at the end of the text in the given node

This is called automatically when focus lands on a contenteditable element. It queries the text layout to find the position of the last grapheme cluster and places the cursor there.

Returns

true if cursor was successfully initialized, false if the node has no text or text layout is not available.

pub fn initialize_cursor_at_start(&mut self, dom_id: DomId, node_id: NodeId)

Initialize cursor at the start of the text in the given node

This can be used for specific navigation scenarios (e.g., Ctrl+Home).

pub fn move_cursor_to( &mut self, cursor: TextCursor, dom_id: DomId, node_id: NodeId, )

Move the cursor to a specific position

This is used by text editing operations and keyboard navigation.

pub fn is_cursor_in_node(&self, dom_id: DomId, node_id: NodeId) -> bool

Check if the cursor is in a specific node

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

Get the DomNodeId where the cursor is located (for cross-frame tracking)

pub fn update_node_id(&mut self, new_node: DomNodeId)

Update the NodeId for the cursor location (after DOM reconciliation)

This is called when the DOM is regenerated and NodeIds change. The cursor position within the text is preserved.

pub fn remap_node_ids( &mut self, dom_id: DomId, node_id_map: &BTreeMap<NodeId, NodeId>, )

Remap NodeIds after DOM reconciliation

When the DOM is regenerated, NodeIds can change. This method updates the cursor location to use the new NodeId based on the provided mapping.

Trait Implementations

impl Clone for CursorManager

fn clone(&self) -> CursorManager

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CursorManager

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

Formats the value using the given formatter.

impl Default for CursorManager

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for CursorManager

fn eq(&self, other: &Self) -> 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.