Struct DataGridState 

pub struct DataGridState<T: TableRow> { /* private fields */ }

State for a DataGrid component.

Contains the table data, column cursor, and inline editor state.

Implementations

impl<T: TableRow> DataGridState<T>

pub fn new(rows: Vec<T>, columns: Vec<Column>) -> Self

Creates a new data grid with the given rows and columns.

The first row is selected by default.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "A".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
assert_eq!(state.selected_index(), Some(0));
assert_eq!(state.selected_column(), 0);

pub fn rows(&self) -> &[T]

Returns the rows.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "A".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
assert_eq!(state.rows().len(), 1);

pub fn columns(&self) -> &[Column]

Returns the columns.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "A".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
assert_eq!(state.columns().len(), 1);
assert_eq!(state.columns()[0].header(), "Name");

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

Returns the currently selected row index.

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

Alias for selected_index().

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "A".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
assert_eq!(state.selected(), Some(0));

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

Returns a reference to the currently selected row.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "Alice".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
assert_eq!(state.selected_row().unwrap().name, "Alice");

pub fn selected_item(&self) -> Option<&T>

Returns a reference to the currently selected item.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "Bob".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
assert_eq!(state.selected_item().unwrap().name, "Bob");

pub fn set_selected(&mut self, index: Option<usize>)

Sets the selected row index.

The index is clamped to the valid range. Has no effect on empty grids. Cancels any active edit.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let mut state = DataGridState::new(
    vec![Item { name: "A".into() }, Item { name: "B".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
state.set_selected(Some(1));
assert_eq!(state.selected_index(), Some(1));

pub fn selected_column(&self) -> usize

Returns the currently selected column index.

pub fn is_editing(&self) -> bool

Returns true if a cell is currently being edited.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "A".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
assert!(!state.is_editing());

pub fn editor_value(&self) -> &str

Returns the current editor value (while editing).

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "A".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
assert_eq!(state.editor_value(), "");

pub fn current_cell_value(&self) -> Option<String>

Returns the value of the currently selected cell.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "Alice".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
assert_eq!(state.current_cell_value(), Some("Alice".to_string()));

pub fn row_count(&self) -> usize

Returns the number of rows.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "A".into() }, Item { name: "B".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
assert_eq!(state.row_count(), 2);

pub fn column_count(&self) -> usize

Returns the number of columns.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state = DataGridState::new(
    vec![Item { name: "A".into() }],
    vec![
        Column::new("Name", Constraint::Min(10)),
        Column::new("Value", Constraint::Min(5)),
    ],
);
assert_eq!(state.column_count(), 2);

pub fn is_empty(&self) -> bool

Returns true if the grid has no rows.

Example

use envision::component::{DataGridState, TableRow, Column};

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let state: DataGridState<Item> = DataGridState::default();
assert!(state.is_empty());

pub fn set_rows(&mut self, rows: Vec<T>)

Sets the rows, resetting selection and cancelling any edit.

Example

use envision::component::{DataGridState, TableRow, Column};
use ratatui::layout::Constraint;

#[derive(Clone)]
struct Item { name: String }
impl TableRow for Item {
    fn cells(&self) -> Vec<String> { vec![self.name.clone()] }
}

let mut state = DataGridState::new(
    vec![Item { name: "A".into() }],
    vec![Column::new("Name", Constraint::Min(10))],
);
state.set_rows(vec![Item { name: "X".into() }, Item { name: "Y".into() }]);
assert_eq!(state.row_count(), 2);

impl<T: TableRow + 'static> DataGridState<T>

pub fn update(&mut self, msg: DataGridMessage) -> Option<DataGridOutput<T>>

Updates the state with a message, returning any output.

Trait Implementations

impl<T: Clone + TableRow> Clone for DataGridState<T>

fn clone(&self) -> DataGridState<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + TableRow> Debug for DataGridState<T>

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

Formats the value using the given formatter.

impl<T: TableRow> Default for DataGridState<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T> Deserialize<'de> for DataGridState<T>

where T: Deserialize<'de> + TableRow,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: TableRow + PartialEq> PartialEq for DataGridState<T>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for DataGridState<T>

where T: Serialize + TableRow,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.