Struct Button 

pub struct Button<M> { /* private fields */ }

A button that can be focused and pressed, declared with component.

After on_press is set, pressing it — Enter, Space, or a left click — returns the message built by that handler. Without a handler the button is not focusable and ignores activation keys and clicks; use ButtonWidget when only painting is needed. Right and middle clicks do nothing. Painting is delegated to ButtonWidget; this half adds focus and event handling.

A button holds no state of its own. Its label and disabledness are values you pass at declaration, which means they come from app state and there is nothing to keep in sync. Those declared values also stay in effect for event handling until the next successful render, so a click arriving between an update and a redraw is judged against the button the user actually saw.

use ratcn::Button;

let _button = Button::new("Delete")
    .destructive()
    .disabled(!state.can_delete)
    .on_press(|| Msg::Delete);

Implementations

impl<M> Button<M>

pub fn new(label: impl Into<String>) -> Self

A default-variant button labelled label.

It does nothing until on_press gives it a message to emit. Without one it is not focusable and ignores activation keys and clicks. Use ButtonWidget instead for paint-only presentation.

pub fn on_press(self, on_press: impl Fn() -> M + 'static) -> Self

What to emit when the button is pressed: Enter, Space, or a left click.

pub const fn disabled(self, disabled: bool) -> Self

Grey the button out and stop it responding.

A disabled button is not focusable, so Tab skips it, and it ignores events rather than consuming them. Focus already parked on it stays there. Pass the value from app state (.disabled(!state.can_save)).

pub fn variant(self, variant: ButtonVariant) -> Self

Set the visual variant. See ButtonVariant.

pub fn outline(self) -> Self

Shorthand for ButtonVariant::Outline.

pub fn secondary(self) -> Self

Shorthand for ButtonVariant::Secondary.

pub fn ghost(self) -> Self

Shorthand for ButtonVariant::Ghost.

pub fn destructive(self) -> Self

Shorthand for ButtonVariant::Destructive.

pub const fn size(self, size: ButtonSize) -> Self

Set the height, one row or three. See ButtonSize.

pub fn style(self, style: impl Fn(&Theme) -> ButtonStyle + 'static) -> Self

Replace the ButtonStyle the theme and variant derive. Resolved from the active theme at render time, so a style built from theme follows theme switches; a fixed style ignores the argument (|_| STYLE).

use ratcn::{Button, ButtonStyle, ButtonVariant};

let _button = Button::new("Archive").on_press(|| Msg::Archive).style(|theme| {
    let mut style = ButtonStyle::from_theme(theme, ButtonVariant::Default);
    style.background = theme.accent;
    style
});

pub fn width(&self) -> u16

Columns this button needs: the label in terminal cells, plus two cells of padding on each side.

Build layout constraints from the same instance you are about to declare, so the constraint and the paint cannot disagree.

Trait Implementations

impl<S, M> Component<S, M> for Button<M>

fn declare(&mut self, _ctx: &mut DeclareCtx<'_, S, M>)

Declare the component: lay out its area, declare its descendants, and record whatever handle_event will need to read back.

fn paint(&mut self, ctx: &mut PaintCtx<'_, S>)

Paint the component. ctx carries the paint surface, area, app state, theme, and interaction state.

fn handle_event( &mut self, event: &Event, _state: &S, _ctx: &mut EventCtx<'_>, ) -> EventResult<M>

Offer this component an event.

fn scope_options(&self) -> ScopeOptions

The scope this component opens around its descendants. Read once, before declare, so it cannot depend on paint.

fn interaction_area(&self, area: Rect) -> Rect

Return the area used for focus, hit-testing, and event routing.

fn prepare(&mut self, _state: &State)

Prepare this component from the state it is being declared with.

fn reveal_in_viewport( &mut self, _target: Rect, _state: &State, _ctx: &mut EventCtx<'_>, )

Bring target into view inside this component’s viewport.

impl<M> Debug for Button<M>

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

Formats the value using the given formatter.

impl<S, M> MeasuredComponent<S, M> for Button<M>

fn measure(&self) -> Size

The component’s preferred width and height in terminal cells.