Struct TableState 

pub struct TableState<D: TableDelegate> {
    pub loop_selection: bool,
    pub col_selectable: bool,
    pub row_selectable: bool,
    pub cell_selectable: bool,
    pub row_header: bool,
    pub sortable: bool,
    pub col_resizable: bool,
    pub col_movable: bool,
    pub col_fixed: bool,
    pub vertical_scroll_handle: UniformListScrollHandle,
    pub horizontal_scroll_handle: VirtualListScrollHandle,
    /* private fields */
}

Fields

loop_selection: bool

Whether the table can loop selection, default is true.

When the prev/next selection is out of the table bounds, the selection will loop to the other side.

col_selectable: bool

Whether the table can select column.

row_selectable: bool

Whether the table can select row.

cell_selectable: bool

Whether the table can select cell, default is false.

When enabled:

• Users can click on individual cells to select them
• A row header column appears on the left for selecting entire rows (can be hidden via Self::row_header)
• Keyboard navigation works at the cell level (arrow keys move between cells)
• Right-click and double-click events are supported for cells

row_header: bool

Whether the row header column is visible when cell_selectable is enabled, default is true.

Set to false to hide the narrow leftmost header column while keeping cell selection — useful when you want to put your own content (e.g. a row index column) on the left. When hidden, clicking the already-selected cell again escalates the selection to the whole row so users can still pick rows; row escalation requires row_selectable to be enabled.

sortable: bool

Whether the table can sort.

col_resizable: bool

Whether the table can resize columns.

col_movable: bool

Whether the table can move columns.

col_fixed: bool

Enable/disable fixed columns feature.

vertical_scroll_handle: UniformListScrollHandle

horizontal_scroll_handle: VirtualListScrollHandle

Implementations

impl<D> TableState<D>

where D: TableDelegate,

pub fn new(delegate: D, _: &mut Window, cx: &mut Context<'_, Self>) -> Self

Create a new TableState with the given delegate.

pub fn delegate(&self) -> &D

Returns a reference to the delegate.

pub fn delegate_mut(&mut self) -> &mut D

Returns a mutable reference to the delegate.

pub fn loop_selection(self, loop_selection: bool) -> Self

Set to loop selection, default to true.

pub fn col_movable(self, col_movable: bool) -> Self

Set to enable/disable column movable, default to true.

pub fn col_resizable(self, col_resizable: bool) -> Self

Set to enable/disable column resizable, default to true.

pub fn sortable(self, sortable: bool) -> Self

Set to enable/disable column sortable, default true

pub fn row_selectable(self, row_selectable: bool) -> Self

Set to enable/disable row selectable, default true

pub fn col_selectable(self, col_selectable: bool) -> Self

Set to enable/disable column selectable, default true

pub fn cell_selectable(self, cell_selectable: bool) -> Self

Set to enable/disable cell selection, default is false.

When enabled:

• Individual cells become selectable by clicking
• A row header column appears on the left side (can be hidden via Self::row_header)
• Keyboard navigation operates at the cell level
• Cell-specific events (SelectCell, DoubleClickedCell, RightClickedCell) are emitted

Example

let table_state = cx.new(|cx| {
    TableState::new(delegate, cx)
        .cell_selectable(true)  // Enable cell selection
        .row_selectable(true)   // Also allow row selection via row header
});

pub fn row_header(self, row_header: bool) -> Self

Set whether the row header column is shown, default is true.

Only effective when cell_selectable is true — otherwise the row header column is never rendered. Hide it when you want to use the leftmost column for your own content (e.g. a row index column).

When hidden, the first click on a cell selects the cell; clicking the already-selected cell again escalates to selecting the whole row, so users can still pick rows without the dedicated header column. The row escalation requires row_selectable to be enabled.

pub fn refresh(&mut self, cx: &mut Context<'_, Self>)

When we update columns or rows, we need to refresh the table.

pub fn scroll_to_row(&mut self, row_ix: usize, cx: &mut Context<'_, Self>)

Scroll to the row at the given index.

pub fn scroll_to_col(&mut self, col_ix: usize, cx: &mut Context<'_, Self>)

pub fn selected_row(&self) -> Option<usize>

Returns the selected row index.

pub fn set_selected_row(&mut self, row_ix: usize, cx: &mut Context<'_, Self>)

Sets the selected row to the given index.

pub fn right_clicked_row(&self) -> Option<usize>

Returns the row that has been right clicked.

pub fn set_right_clicked_row( &mut self, row: Option<usize>, cx: &mut Context<'_, Self>, )

Set or clear the right-clicked row state.

Pass None to clear — useful when opening a header context menu to prevent the row context menu from appearing simultaneously.

pub fn selected_col(&self) -> Option<usize>

Returns the selected column index.

pub fn set_selected_col(&mut self, col_ix: usize, cx: &mut Context<'_, Self>)

Sets the selected col to the given index.

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

Returns the selected cell as (row_ix, col_ix).

Returns None if no cell is currently selected or if the table is in row/column selection mode.

Example

if let Some((row_ix, col_ix)) = table_state.read(cx).selected_cell() {
    println!("Selected cell: ({}, {})", row_ix, col_ix);
}

pub fn set_selected_cell( &mut self, row_ix: usize, col_ix: usize, cx: &mut Context<'_, Self>, )

Sets the selected cell to the given row and column indices.

This method:

• Switches the table to cell selection mode
• Scrolls to make the cell visible (centered vertically)
• Emits a TableEvent::SelectCell event

Example

// Select the cell at row 5, column 3
table_state.update(cx, |state, cx| {
    state.set_selected_cell(5, 3, cx);
});

pub fn clear_selection(&mut self, cx: &mut Context<'_, Self>)

Clear the selection of the table.

pub fn visible_range(&self) -> &TableVisibleRange

Returns the visible range of the rows and columns.

See TableVisibleRange.

pub fn headers(&self, cx: &App) -> Vec<String>

Dump the header row of the table.

Batched exporters can read the headers once with this, then stream the rows with Self::dump_range.

pub fn dump(&self, cx: &App) -> (Vec<String>, Vec<Vec<String>>)

Dump table data.

Returns a tuple of (headers, rows) where each row is a vector of cell values.

This materializes the complete table in memory. For large tables, prefer Self::dump_range and process rows in batches.

pub fn dump_range( &self, range: Range<usize>, cx: &App, ) -> (Vec<String>, Vec<Vec<String>>)

Dump table data for the specified row range.

Returns the same (headers, rows) shape as Self::dump, with only the rows inside the clamped range.

The requested range is clamped to the table’s current row count. For large tables, callers can invoke this repeatedly with bounded ranges.

pub fn refresh_header_layout(&mut self, cx: &mut Context<'_, Self>)

Re-compute the header layout from the current delegate.

Call this after changing delegate state that affects group_headers.

Trait Implementations

impl<D> EventEmitter<TableEvent> for TableState<D>

where D: TableDelegate,

impl<D> Focusable for TableState<D>

where D: TableDelegate,

fn focus_handle(&self, _cx: &App) -> FocusHandle

Returns the focus handle associated with this view.

impl<D> Render for TableState<D>

where D: TableDelegate,

fn render( &mut self, window: &mut Window, cx: &mut Context<'_, Self>, ) -> impl IntoElement

Render this view into an element tree.