Struct Button 

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

Button widget.

A clickable button with various display styles.

Implementations

impl<'a> Button<'a>

pub fn new(label: &'a str, state: &'a ButtonState) -> Self

Create a new button.

Arguments

• label - The button text
• state - Reference to the button state

pub fn icon(self, icon: &'a str) -> Self

Set an icon to display before the label.

pub fn style(self, style: ButtonStyle) -> Self

Set the button style.

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

Set the button variant.

pub fn focus_id(self, id: FocusId) -> Self

Set the focus ID.

pub fn alignment(self, alignment: Alignment) -> Self

Set the text alignment.

pub fn min_width(&self) -> u16

Calculate minimum width for this button.

pub fn min_height(&self) -> u16

Calculate minimum height for this button.

pub fn render_stateful( self, area: Rect, buf: &mut Buffer, ) -> ClickRegion<ButtonAction>

Render the button and return the click region.

This method renders the button and returns a ClickRegion that you must register with a ClickRegionRegistry to enable mouse click support.

For a more convenient API, consider using render_with_registry() which handles both rendering and registration in one call.

Example

use ratatui_interact::components::{Button, ButtonState};
use ratatui_interact::traits::ClickRegionRegistry;
use ratatui::layout::Rect;
use ratatui::buffer::Buffer;

let state = ButtonState::enabled();
let button = Button::new("OK", &state);
let area = Rect::new(0, 0, 10, 1);
let mut buf = Buffer::empty(Rect::new(0, 0, 20, 5));
let mut registry: ClickRegionRegistry<usize> = ClickRegionRegistry::new();

let region = button.render_stateful(area, &mut buf);
registry.register(region.area, 0);

pub fn render_with_registry<D: Clone>( self, area: Rect, buf: &mut Buffer, registry: &mut ClickRegionRegistry<D>, data: D, )

Render the button and automatically register its click region.

This is a convenience method that combines render_stateful() with registry registration. Use this when you have a ClickRegionRegistry and want to avoid the two-step render + register pattern.

Arguments

• area - The area to render the button in
• buf - The buffer to render to
• registry - The click region registry to register with
• data - The data to associate with this button’s click region

Example

use ratatui_interact::components::{Button, ButtonState};
use ratatui_interact::traits::ClickRegionRegistry;
use ratatui::layout::Rect;
use ratatui::buffer::Buffer;

let state = ButtonState::enabled();
let mut registry: ClickRegionRegistry<usize> = ClickRegionRegistry::new();

// Clear before each render cycle
registry.clear();

let button = Button::new("OK", &state);
let area = Rect::new(0, 0, 10, 1);
let mut buf = Buffer::empty(Rect::new(0, 0, 20, 5));

// Render and register in one call
button.render_with_registry(area, &mut buf, &mut registry, 0);

// Later, check for clicks
if let Some(&idx) = registry.handle_click(5, 0) {
    println!("Button {} clicked!", idx);
}

Trait Implementations

impl Widget for Button<'_>

fn render(self, area: Rect, buf: &mut Buffer)

Draws the current state of the widget in the given buffer. That is the only method required to implement a custom widget.