Struct FocusManager 

pub struct FocusManager<O = (), M = ()> { /* private fields */ }

Implementations

impl<O, M> FocusManager<O, M>

pub fn new() -> Self

pub fn focus_wrap(&self) -> FocusWrap

The current end-of-list navigation policy.

pub fn set_focus_wrap(&mut self, wrap: FocusWrap)

Set the end-of-list navigation policy (clamp vs. wrap-around).

pub fn targets(&self) -> &[FocusTarget<O>]

pub fn overlay(&self) -> Option<&OverlayFocus<O, M>>

pub fn overlay_mut(&mut self) -> Option<&mut OverlayFocus<O, M>>

pub fn register_page(&mut self, targets: Vec<FocusTarget<O>>)

pub fn set_section_items(&mut self, section_items: Vec<(usize, usize)>)

Record the (section_id, item_count) pairs for the current page so the runtime can enter a section on its own (see activate). The runtime calls this from refresh_page; applications rarely need to.

pub fn has_overlay(&self) -> bool

pub fn next(&mut self)

pub fn prev(&mut self)

pub fn show_modal(&mut self, data: M, count: usize)

Open a generic modal overlay carrying data with count selectable items. Pass count == 0 for a non-interactive modal (e.g. a loading dialog). Higher-level conventions (dialogs, pickers) build on this.

pub fn clear_overlay(&mut self)

pub fn exit_canvas_forward(&mut self)

pub fn exit_canvas_backward(&mut self)

pub fn enter_section(&mut self, item_count: usize)

pub fn activate(&mut self)

Act on the currently focused target without the application inspecting focus: if it is a Section registered with an item count (see section_with_items), enter it. Anything else — a button, an already-entered section, an open overlay — is left untouched, so the application’s own activation logic (navigation, selection) stays its own concern.

pub fn enter_section_at( &mut self, section_id: usize, item_count: usize, item_index: usize, )

pub fn leave_section(&mut self)

impl<O: Clone, M> FocusManager<O, M>

pub fn current(&self) -> Option<FocusTarget<O>>

pub fn query(&self) -> FocusQuery<O>

impl<O: Clone + PartialEq, M> FocusManager<O, M>

pub fn is_focused(&self, target: &FocusTarget<O>) -> bool

pub fn add_target(&mut self, target: FocusTarget<O>)

pub fn remove_target(&mut self, target: &FocusTarget<O>)

pub fn set_focus(&mut self, target: FocusTarget<O>)

pub fn open_overlay(&mut self, target: FocusTarget<O>)

pub fn close_overlay(&mut self, target: FocusTarget<O>)

pub fn toggle_overlay(&mut self, target: FocusTarget<O>)

pub fn is_overlay_open(&self, target: &FocusTarget<O>) -> bool

Trait Implementations

impl<O: Clone, M: Clone> Clone for FocusManager<O, M>

fn clone(&self) -> FocusManager<O, M>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<O: Debug, M: Debug> Debug for FocusManager<O, M>

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

Formats the value using the given formatter.

impl<O, M> Default for FocusManager<O, M>

fn default() -> Self

Returns the “default value” for a type.

impl<O: Clone + PartialEq, M> FocusController<O, M> for FocusManager<O, M>

fn apply_focus_intent(&mut self, intent: FocusIntent<O, M>)

impl<O: PartialEq, M: PartialEq> PartialEq for FocusManager<O, M>

fn eq(&self, other: &FocusManager<O, M>) -> 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<O: Eq, M: Eq> Eq for FocusManager<O, M>

impl<O, M> StructuralPartialEq for FocusManager<O, M>