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 might be useful if you create compound widgets. Then you can have the focus state for each contained widget, and an overall state for the compound.

If your compound widget contains compound widgets itself, you let each of the components create their own Focus and add everything together with append.

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 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.