Struct rat_focus::Focus

pub struct Focus<'a> { /* private fields */ }

Keeps track of the focus.

It works by adding a FocusFlag to the State of a widget. Focus is constructed with a list of references to these flags and switches the focus that way. Each widget stays separate otherwise and can pull its focus state from this struct.

use rat_focus::Focus;

let f = Focus::new(&[
    &widget1,
    &widget2
]).handle(evt, FocusKeys);

The result f indicates whether the focus has changed.

Implementations

impl<'a> Focus<'a>

pub fn new(list: &[&'a dyn HasFocusFlag]) -> Self

Construct a new focus list.

pub fn new_accu( accu: &'a dyn HasFocusFlag, list: &[&'a dyn HasFocusFlag] ) -> Self

Construct a new focus list with an accumulator.

The accumulator has its focus set if any of the contained flags has the focus.

If you have a Focus you can append the Focus of a subcomponent with append. In that case the accumulator of the subcomponent gets its lost+gained flags set too, if you switch the focus between different subcomponents.

See examples/focus_recursive and examples/focus_recursive2

pub fn append(self, focus: Focus<'a>) -> Self

Add a sub-focus cycle.

All its widgets are appended to this list. If the sub-cycle has an accumulator it’s added to the accumulators. All sub-accumulators are appended too.

pub fn init(&self)

Set the initial state for all widgets. This ensures that there is only one focused widget. The first widget in the list gets the focus.

pub fn focus_widget_no_lost(&self, state: &'a dyn HasFocusFlag)

Sets the focus to the widget.

Sets focus and gained but not lost. This can be used to prevent validation of the field.

pub fn focus_widget(&self, state: &'a dyn HasFocusFlag)

Sets the focus to the widget with tag.

Sets the focus, gained and lost flags. If this ends up with the same widget as before focus, gained and lost flag are all set.

pub fn focus_no_lost(&self, flag: &FocusFlag)

Sets the focus to the widget.

Sets focus and gained but not lost. This can be used to prevent validation of the field.

pub fn focus(&self, flag: &FocusFlag)

Sets the focus to the widget with tag.

Sets the focus, gained and lost flags. If this ends up with the same widget as before focus, gained and lost flag are all set.

pub fn reset_lost_gained(&self)

Reset lost + gained flags. This is done automatically in HandleEvent::handle() for every event.

pub fn focus_idx(&self, idx: usize)

Change the focus.

Sets the focus, gained and lost flags.

If the field at idx has the focus all three are set.

pub fn focus_at(&self, col: u16, row: u16) -> bool

Change to focus to the given position.

pub fn next(&self) -> bool

Focus the next widget in the cycle.

Sets the focus, gained and lost flags. If this ends up with the same widget as before focus, gained and lost flag are all set.

If no field has the focus the first one gets it.

pub fn prev(&self) -> bool

Focus the previous widget in the cycle.

Sets the focus and lost flags. If this ends up with the same widget as before it returns true and sets the focus, gained and lost flag.

If no field has the focus the first one gets it.

Trait Implementations

impl<'a> Debug for Focus<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Focus<'a>

fn default() -> Focus<'a>

Returns the “default value” for a type.

impl<'a> HandleEvent<Event, FocusKeys, Outcome> for Focus<'a>

fn handle(&mut self, event: &Event, _keymap: FocusKeys) -> Outcome

Handle an event.

impl<'a> HandleEvent<Event, MouseOnly, Outcome> for Focus<'a>

fn handle(&mut self, event: &Event, _keymap: MouseOnly) -> Outcome

Handle an event.

impl<'a> IntoIterator for Focus<'a>

type Item = (&'a FocusFlag, Rect)

The type of the elements being iterated over.

type IntoIter = Zip<IntoIter<&'a FocusFlag>, IntoIter<Rect>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.