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 for a container widget.

The focus-flag for the container accumulates all the flags. If any has focus, the container has the focus too. Focus-gained and focus-lost are only set if the focus leaves the container.

The container widget itself interacts with the mouse too. If no single widget is hit with the mouse, but the area of the container is, the first widget gets the focus.

See examples/focus_recursive and examples/focus_recursive2

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

Construct a new focus list with group accumulator.

This is meant for some loose grouping of widgets, for which you want an overview.

The same rules apply as for new_accu(), but with this one there is no overall area for mouse interaction.

pub fn add_flag(&mut self, flag: &'a FocusFlag, area: Rect) -> &mut Self

Add a single widget.

pub fn add_focus(&mut self, focus: Focus<'a>) -> &mut 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 sub-accumulators. All sub-sub-accumulators are appended too.

pub fn add_container(&mut self, container: &'a dyn HasFocus) -> &mut Self

Add a container widget.

pub fn add(&mut self, f: &'a dyn HasFocusFlag) -> &mut Self

Add a single widget.

pub fn add_all(&mut self, list: &[&'a dyn HasFocusFlag]) -> &mut Self

Add a list of widgets.

pub fn enable_log(&self, log: bool)

Writes a log for each operation.

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 clear(&self)

Clears the focus state for all widgets. This is useful, if part of your widgets are temporarily exempt from focus handling, and should therefore not have any focus-flags set to avoid problems with event-handling.

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 focused(&self) -> Option<&'a FocusFlag>

Returns the focused widget as FocusFlag.

This is mainly for debugging purposes. For control-flow match_focus or on_gained or on_lost will be nicer.

pub fn lost_focus(&self) -> Option<&'a FocusFlag>

Returns the widget that lost the focus as FocusFlag.

This is mainly for debugging purposes. For control-flow match_focus or on_gained or on_lost will be nicer.

pub fn gained_focus(&self) -> Option<&'a FocusFlag>

Returns the widget that gained the focus as FocusFlag.

This is mainly for debugging purposes. For control-flow match_focus or on_gained or on_lost will be nicer.

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.