Struct Table 

pub struct Table {
    pub style: Style,
    pub cell_bg_color: Color,
    pub selected_color: Color,
    pub text_color: Color,
    pub grid_color: Color,
    /* private fields */
}

LVGL-parity table widget.

Stores cells as a flat row-major Vec; column widths as a Vec<i32>. Row heights are computed dynamically from the cell content using the LPAR-08 shared wrap_greedy_ltr measurement.

Fields

style: Style

Background and outer border style.

cell_bg_color: Color

Color for cell background and grid lines.

selected_color: Color

Color for the selected cell background.

text_color: Color

Text color.

grid_color: Color

Grid line color.

Implementations

impl Table

pub fn new(bounds: Rect) -> Table

Create an empty table at bounds with 0 rows and 0 columns.

Examples found in repository

examples/demo.rs (line 119)

fn main() {
    let theme = Theme::material_light();
    let style = StyleBuilder::new()
        .bg(theme.tokens.colors.primary)
        .radius(theme.tokens.radii.md)
        .build();

    let new_components = (
        Progress::new(theme.control_rect(0, 0, 90, ComponentSize::Sm), 0, 100)
            .with_value(64)
            .themed(
                &theme,
                ColorScheme::Primary,
                Variant::Subtle,
                ComponentSize::Md,
            )
            .opacity(220),
        Select::new(theme.control_rect(0, 10, 90, ComponentSize::Sm).height(64))
            .with_options(&["One", "Two", "Three"])
            .with_selected_index(1)
            .themed(
                &theme,
                ColorScheme::Info,
                Variant::Outline,
                ComponentSize::Sm,
            )
            .on_change(|idx, text| println!("select: {idx} {text}")),
        Tabs::new(rect(0, 80, 120, 80), TabBarPos::Top)
            .tab("Main")
            .tab("Settings")
            .themed(
                &theme,
                ColorScheme::Primary,
                Variant::Solid,
                ComponentSize::Md,
            ),
        ButtonMatrix::new(
            theme
                .control_rect(0, 170, 120, ComponentSize::Md)
                .height(48),
        )
        .with_map(&["A", "B", "\n", "C", "D"])
        .themed(
            &theme,
            ColorScheme::Neutral,
            Variant::Outline,
            ComponentSize::Md,
        )
        .on_activate(|id, text| println!("button matrix: {:?} {text}", id)),
        Bar::new(theme.control_rect(0, 224, 90, ComponentSize::Xs), 0, 100)
            .with_value(32)
            .with_mode(BarMode::Normal)
            .themed(
                &theme,
                ColorScheme::Success,
                Variant::Subtle,
                ComponentSize::Sm,
            ),
        Led::new(
            theme
                .origin_control_rect(12, ComponentSize::Xs)
                .at(0, 240)
                .size(12, 12),
        )
        .themed(
            &theme,
            ColorScheme::Success,
            Variant::Solid,
            ComponentSize::Xs,
        )
        .brightness(180),
        Spinner::new(theme.origin_control_rect(24, ComponentSize::Md).at(20, 236))
            .animation(30, 100)
            .themed(
                &theme,
                ColorScheme::Primary,
                Variant::Ghost,
                ComponentSize::Md,
            ),
        List::new(
            theme
                .control_rect(0, 270, 100, ComponentSize::Sm)
                .height(48),
        )
        .with_items(&["Alpha", "Beta", "Gamma"])
        .themed(
            &theme,
            ColorScheme::Neutral,
            Variant::Subtle,
            ComponentSize::Sm,
        ),
        Divider::new(rect(0, 328, 100, 8), DividerOrientation::Horizontal).themed(
            &theme,
            ColorScheme::Neutral,
            Variant::Outline,
            ComponentSize::Sm,
        ),
        Spacer::height(theme.component_size(ComponentSize::Md).gap),
        Table::new(rect(0, 342, 120, 48)).themed_parts(
            &theme,
            ColorScheme::Info,
            Variant::Subtle,
            ComponentSize::Sm,
        ),
        Calendar::new(rect(0, 396, 140, 96)).themed_parts(
            &theme,
            ColorScheme::Primary,
            Variant::Outline,
            ComponentSize::Sm,
        ),
    );

    let layout = {
        #[cfg(feature = "view")]
        {
            view! { VStack::new(90)
            .child(20, |rect| Heading::new("Demo", rect))
            .child(20, |rect| Text::new("Hello", rect))
            .child(30, |rect| {
                Button::new("Tap", rect)
                    .icon("save")
                    .on_click(|_| println!("clicked"))
            })
            .child(30, |rect| {
                IconButton::new("edit", rect)
                    .on_click(|_| println!("edit"))
            })
            .child(20, |rect| {
                Checkbox::new("Accept", rect).on_change(|v| println!("checkbox: {v}"))
            })
            .child(20, |rect| {
                Switch::new(rect).on_change(|v| println!("switch: {v}"))
            })
            .child(20, |rect| {
                Radio::new("Option", rect).on_change(|v| println!("radio: {v}"))
            })
            .child(20, |rect| { Badge::new("NEW", rect) })
            .child(20, |rect| {
                Tag::new("rust", rect).on_remove(|| println!("tag removed"))
            })
            .child(30, |rect| { Alert::new("Saved", rect) })
            .child(20, |rect| {
                Input::new("Name", rect).on_change(|v| println!("input: {v}"))
            })
            .child(40, |rect| {
                Textarea::new("Multiline", rect).on_change(|v| println!("textarea: {v}"))
            })
            .child(30, |rect| Modal::new("Modal", rect))
            .child(30, |rect| Drawer::new("Menu", rect))
            .child(30, |rect| Toast::new("Saved", rect)) }
        }
        #[cfg(not(feature = "view"))]
        {
            VStack::new(90)
                .child(20, |rect| Heading::new("Demo", rect))
                .child(20, |rect| Text::new("Hello", rect))
                .child(30, |rect| {
                    Button::new("Tap", rect)
                        .icon("save")
                        .on_click(|_| println!("clicked"))
                })
                .child(30, |rect| {
                    IconButton::new("edit", rect).on_click(|_| println!("edit"))
                })
                .child(20, |rect| {
                    Checkbox::new("Accept", rect).on_change(|v| println!("checkbox: {v}"))
                })
                .child(20, |rect| {
                    Switch::new(rect).on_change(|v| println!("switch: {v}"))
                })
                .child(20, |rect| {
                    Radio::new("Option", rect).on_change(|v| println!("radio: {v}"))
                })
                .child(20, |rect| Badge::new("NEW", rect))
                .child(20, |rect| {
                    Tag::new("rust", rect).on_remove(|| println!("tag removed"))
                })
                .child(30, |rect| Alert::new("Saved", rect))
                .child(20, |rect| {
                    Input::new("Name", rect).on_change(|v| println!("input: {v}"))
                })
                .child(40, |rect| {
                    Textarea::new("Multiline", rect).on_change(|v| println!("textarea: {v}"))
                })
                .child(30, |rect| Modal::new("Modal", rect))
                .child(30, |rect| Drawer::new("Menu", rect))
                .child(30, |rect| Toast::new("Saved", rect))
        }
    };

    let _ = (style, new_components, layout);
}

pub fn set_font(&mut self, font: &'static dyn FontMetrics)

Assign the font used to render this widget (FONT-00 §5); resolves to FONT_6X10 when unset.

pub fn row_count(&self) -> usize

Return the number of rows.

pub fn column_count(&self) -> usize

Return the number of columns.

pub fn set_row_count(&mut self, rows: usize)

Set the number of rows, extending or truncating the cell vector.

pub fn set_column_count(&mut self, cols: usize)

Set the number of columns, extending or truncating; preserves existing cell content where indices overlap.

pub fn set_cell_value(&mut self, row: usize, col: usize, text: &str)

Set the text value of a cell.

Out-of-bounds indices are silently ignored (matching LVGL behavior).

pub fn cell_value(&self, row: usize, col: usize) -> Option<&str>

Return the text value of a cell, or None if empty or out of bounds.

pub fn set_cell_ctrl(&mut self, row: usize, col: usize, ctrl: CellCtrl)

Set control flags for a cell.

pub fn cell_ctrl(&self, row: usize, col: usize) -> CellCtrl

Return control flags for a cell.

pub fn set_cell_align(&mut self, row: usize, col: usize, align: CellAlign)

Set horizontal alignment for a cell.

pub fn set_column_width(&mut self, col: usize, width: i32)

Set the pixel width of column col.

A width of 0 means “auto” — the column participates in the remaining width distribution.

pub fn column_width(&self, col: usize) -> i32

Return the stored column width (0 = auto).

pub fn set_selected_cell(&mut self, row: usize, col: usize)

Set the selected cell. Out-of-bounds is silently ignored.

pub fn selected_cell(&self) -> Option<(usize, usize)>

Return the selected cell (row, col), or None if nothing is selected.

pub fn navigate_next(&mut self)

Move selection to the next cell (right then down; wraps at the last cell to the first).

Wire to ObjectEvent::Key(Key::ArrowRight) or Key::Tab in a node handler.

pub fn navigate_prev(&mut self)

Move selection to the previous cell (left then up; wraps at the first cell to the last).

Wire to ObjectEvent::Key(Key::ArrowLeft) or Key::BackTab.

pub fn navigate_up(&mut self)

Move selection one row up.

Wire to ObjectEvent::Key(Key::ArrowUp) in a node handler.

pub fn navigate_down(&mut self)

Move selection one row down.

Wire to ObjectEvent::Key(Key::ArrowDown) in a node handler.

pub fn activate_selected(&mut self)

Activate the selected cell and record it in the poll slot.

Wire to ObjectEvent::Key(Key::Enter) in a node handler.

pub fn last_activated(&mut self) -> Option<(usize, usize)>

Drain the activation poll slot.

Trait Implementations

impl StyleProps for Table

fn style_mut(&mut self) -> &mut Style

Return the mutable style used by this widget’s main visual part.

fn with_style(self, style: Style) -> Self

Replace the complete main style.

fn bg(self, color: Color) -> Self

Set the background color.

fn bg_color(self, color: Color) -> Self

Set the background color.

fn border_color(self, color: Color) -> Self

Set the border color.

fn border_width(self, width: u8) -> Self

Set the border width in pixels.

fn radius(self, radius: u8) -> Self

Set the corner radius in pixels.

fn rounded(self, radius: u8) -> Self

Set the corner radius in pixels.

fn opacity(self, alpha: u8) -> Self

Set widget opacity as 0..=255.

fn alpha(self, alpha: u8) -> Self

Set widget opacity as 0..=255.

impl ThemedPartsProps for Table

fn themed_parts( self, theme: &Theme, scheme: ColorScheme, variant: Variant, size: ComponentSize, ) -> Self

Apply the theme to the main style and direct widget-specific part colors.

impl Widget for Table

fn bounds(&self) -> Rect

Return the area this widget occupies relative to its parent.

fn widget_font_mut(&mut self) -> Option<&mut WidgetFont>

Expose this widget’s font slot for cascade-driven font resolution (FONT-05 §5.B).

fn set_bounds(&mut self, bounds: Rect)

Called by the LPAR-10 layout pass to notify this widget of its layout-computed bounds.

fn draw(&self, renderer: &mut dyn Renderer)

Render the widget using the provided Renderer.

fn handle_event(&mut self, _event: &Event) -> bool

Handle an event and return true if it was consumed.

fn clear_region(&mut self) -> Option<Rect>

Return a region (in draw/landscape coordinates) that should be restored from the pristine background copy, or None.