Enum Outcome 

pub enum Outcome {
    Ignored,
    Consumed,
    Changed,
    Submitted,
}

Result of feeding an event to a widget state.

Ignored → the widget did nothing, let someone else handle it. Consumed → handled, redraw is enough (hover moved, cursor blinked, scrolled). Changed → the value the widget owns changed (toggle flipped, text edited, row picked). Submitted → the value was committed (Enter in a field, a row activated, a dialog answered). Editing widgets report Changed per keystroke and Submitted once, so a screen that writes a config on commit does not write it on the first character typed.

The order is the composition order: | keeps the strongest outcome of a fan-out, and is_changed() is true for Submitted as well, since a commit is also a value change.

Variants

Ignored

Consumed

Changed

Submitted

Implementations

impl Outcome

pub fn is_ignored(self) -> bool

pub fn is_consumed(self) -> bool

Anything but Ignored.

Examples found in repository

examples/minimal.rs (line 84)

    fn event(&mut self, ev: Event, _now: Instant) -> Flow {
        if let Event::Key(k) = &ev {
            if ctrl(k, 'c') {
                return Flow::Quit;
            }
            if self.focus.handle_key(*k).is_consumed() {
                return Flow::Continue;
            }
        }
        let out = match (&ev, self.focus.current()) {
            (Event::Key(_), Some(Id::Dark)) => self.dark.handle(&ev),
            (Event::Key(_), Some(Id::Name)) => self.name.handle(&ev),
            (Event::Key(_), Some(Id::Save)) => self.save.handle(&ev),
            // every widget sees every mouse event and checks its own rect
            (Event::Mouse(_), _) => {
                let mut o = self.dark.handle(&ev);
                if o.is_changed() {
                    self.focus.set(Id::Dark);
                }
                let n = self.name.handle(&ev);
                if n.is_consumed() {
                    self.focus.set(Id::Name);
                }
                let s = self.save.handle(&ev);
                if s.is_changed() {
                    self.focus.set(Id::Save);
                }
                o |= n | s;
                o
            }
            _ => Outcome::Ignored,
        };
        if out.is_changed() {
            if self.focus.is(Id::Dark) {
                theme::set_by_name(if self.dark.on {
                    "textual-dark"
                } else {
                    "textual-light"
                });
            }
            if self.focus.is(Id::Save) {
                self.toasts.success(format!("Saved {:?}", self.name.value));
            }
        }
        Flow::Continue
    }

pub fn is_changed(self) -> bool

Changed or Submitted: the value the widget owns is not what it was.

Examples found in repository

examples/minimal.rs (line 95)

    fn event(&mut self, ev: Event, _now: Instant) -> Flow {
        if let Event::Key(k) = &ev {
            if ctrl(k, 'c') {
                return Flow::Quit;
            }
            if self.focus.handle_key(*k).is_consumed() {
                return Flow::Continue;
            }
        }
        let out = match (&ev, self.focus.current()) {
            (Event::Key(_), Some(Id::Dark)) => self.dark.handle(&ev),
            (Event::Key(_), Some(Id::Name)) => self.name.handle(&ev),
            (Event::Key(_), Some(Id::Save)) => self.save.handle(&ev),
            // every widget sees every mouse event and checks its own rect
            (Event::Mouse(_), _) => {
                let mut o = self.dark.handle(&ev);
                if o.is_changed() {
                    self.focus.set(Id::Dark);
                }
                let n = self.name.handle(&ev);
                if n.is_consumed() {
                    self.focus.set(Id::Name);
                }
                let s = self.save.handle(&ev);
                if s.is_changed() {
                    self.focus.set(Id::Save);
                }
                o |= n | s;
                o
            }
            _ => Outcome::Ignored,
        };
        if out.is_changed() {
            if self.focus.is(Id::Dark) {
                theme::set_by_name(if self.dark.on {
                    "textual-dark"
                } else {
                    "textual-light"
                });
            }
            if self.focus.is(Id::Save) {
                self.toasts.success(format!("Saved {:?}", self.name.value));
            }
        }
        Flow::Continue
    }

pub fn is_submitted(self) -> bool

Submitted only: the user committed the value (Enter, activate, answer).

pub fn changed_if(flag: bool) -> Outcome

true → Changed, false → Consumed.

Trait Implementations

impl BitOr for Outcome

type Output = Outcome

The resulting type after applying the | operator.

fn bitor(self, rhs: Outcome) -> Outcome

Performs the | operation.

impl BitOrAssign for Outcome

fn bitor_assign(&mut self, rhs: Outcome)

Performs the |= operation.

impl Clone for Outcome

fn clone(&self) -> Outcome

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Outcome

impl Debug for Outcome

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

Formats the value using the given formatter.

impl Default for Outcome

fn default() -> Outcome

Returns the “default value” for a type.

impl Eq for Outcome

impl Hash for Outcome

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Outcome

fn cmp(&self, other: &Outcome) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Outcome

fn eq(&self, other: &Outcome) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for Outcome

fn partial_cmp(&self, other: &Outcome) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Outcome