Struct rat_ftable::FTable

pub struct FTable<'a, Selection> { /* private fields */ }

FTable widget.

Can be used like a ratatui::Table, but the benefits only show if you use FTable::data to set the table data.

See FTable::data for a sample.

Implementations

impl<'a, Selection> FTable<'a, Selection>

pub fn new<R, C>(rows: R, widths: C) -> Self

where R: IntoIterator, R::Item: Into<Row<'a>>, C: IntoIterator, C::Item: Into<Constraint>, Selection: Default,

Create a new FTable with preformatted data. For compatibility with ratatui.

Use of FTable::data is preferred.

pub fn rows<T>(self, rows: T) -> Self

where T: IntoIterator<Item = Row<'a>>,

Set preformatted row-data. For compatibility with ratatui.

Use of FTable::data is preferred.

pub fn data(self, data: &'a dyn TableData<'a>) -> Self

Set a reference to the TableData facade to your data.

The way to go is to define a small struct that contains just a reference to your data. Then implement TableData for this struct.

use ratatui::buffer::Buffer;
use ratatui::layout::Rect;
use ratatui::prelude::Style;
use ratatui::text::Span;
use ratatui::widgets::Widget;
use rat_ftable::{FTable, FTableState, TableData};


struct Data1<'a>(&'a [SampleRow]);

impl<'a> TableData<'a> for Data1<'a> {
    // returns (cols, rows)
    fn size(&self) -> (usize, usize) {
        (5, self.0.len())
    }

    fn row_height(&self, row: usize) -> u16 {
        // to some calculations ...
        1
    }

    fn row_style(&self, row: usize) -> Style {
        // to some calculations ...
        Style::default()
    }

    fn render_cell(&self, column: usize, row: usize, area: Rect, buf: &mut Buffer) {
        if let Some(data) = self.0.get(row) {
            let rend = match column {
                0 => Span::from("column1"),
                1 => Span::from("column2"),
                2 => Span::from("column3"),
                _ => return
            };
            rend.render(area, buf);
        }
    }
}

// When you are creating the table widget you hand over a reference
// to the facade struct.

let my_data_somewhere_else = vec![SampleRow;999999];
let mut table_state_somewhere_else = FTableState::default();

// ...

let tabledata1 = Data1(&my_data_somewhere_else);
let table1 = FTable::default().data(&tabledata1);
table1.render(area, buf, &mut table_state_somewhere_else);

pub fn iter(self, data: &'a mut dyn TableDataIter<'a>) -> Self

Alternative representation for the data as a kind of Iterator. It uses interior iteration, which fits quite nice for this and avoids handing out lifetime bound results of the actual iterator. Which is a bit nightmarish to get right.

Caution: If you can’t give the number of rows, the table will iterate over all the data.

use std::iter::{Enumerate};
use std::slice::Iter;
use format_num_pattern::NumberFormat;
use ratatui::buffer::Buffer;
use ratatui::layout::{Constraint, Rect};
use ratatui::prelude::Color;
use ratatui::style::{Style, Stylize};
use ratatui::text::Span;
use ratatui::widgets::Widget;
use rat_ftable::{FTable, TableDataIter};

struct Data {
    table_data: Vec<Sample>
}

struct Sample {
    pub text: String
}

let data = Data {
    table_data: vec![],
};

struct RowIter1<'a> {
    iter: Enumerate<Iter<'a, Sample>>,
    item: Option<(usize, &'a Sample)>,
}

impl<'a> TableDataIter<'a> for RowIter1<'a> {
    fn rows(&self) -> Option<usize> {
        // If you can, give the length. Otherwise,
        // the table will iterate all to find out a length.
        None
        // Some(100_000)
    }

    /// Select the nth element from the current position.
    fn nth(&mut self, n: usize) -> bool {
        self.item = self.iter.nth(n);
        self.item.is_some()
    }

    /// Select the next element.
    fn next(&mut self) -> bool {
        self.item = self.iter.next();
        self.item.is_some()
    }

    /// Row height.
    fn row_height(&self) -> u16 {
        1
    }

    /// Row style.
    fn row_style(&self) -> Style {
        Style::default()
    }

    /// Render one cell.
    fn render_cell(&self, column: usize, area: Rect, buf: &mut Buffer) {
        let row = self.item.expect("data");
        match column {
            0 => {
                let row_fmt = NumberFormat::new("000000").expect("fmt");
                let span = Span::from(row_fmt.fmt_u(row.0));
                buf.set_style(area, Style::new().black().bg(Color::from_u32(0xe7c787)));
                span.render(area, buf);
            }
            1 => {
                let span = Span::from(&row.1.text);
                span.render(area, buf);
            }
            _ => {}
        }
    }
}

let mut rit = RowIter1 {
    iter: data.table_data.iter().enumerate(),
    item: None,
};

let table1 = FTable::default()
    .iter(&mut rit)
    .widths([
        Constraint::Length(6),
        Constraint::Length(20)
    ]);

// table1.render(area, buf);

pub fn header(self, header: Row<'a>) -> Self

Set the table-header.

pub fn footer(self, footer: Row<'a>) -> Self

Set the table-footer.

pub fn widths<I>(self, widths: I) -> Self

where I: IntoIterator, I::Item: Into<Constraint>,

Column widths as Constraints.

pub fn flex(self, flex: Flex) -> Self

Flex for layout.

pub fn column_spacing(self, spacing: u16) -> Self

Spacing between columns.

pub fn layout_width(self, width: u16) -> Self

Overrides the width of the rendering area for layout purposes. Layout uses this width, even if it means that some columns are not visible.

pub fn block(self, block: Block<'a>) -> Self

Draws a block around the table widget.

pub fn styles(self, styles: FTableStyle) -> Self

Set all styles as a bundle.

pub fn style<S: Into<Style>>(self, style: S) -> Self

Base style for the table.

pub fn select_row_style<S: Into<Style>>(self, select_style: S) -> Self

Style for a selected row. The chosen selection must support row-selection for this to take effect.

pub fn select_column_style<S: Into<Style>>(self, select_style: S) -> Self

Style for a selected column. The chosen selection must support column-selection for this to take effect.

pub fn select_cell_style<S: Into<Style>>(self, select_style: S) -> Self

Style for a selected cell. The chosen selection must support cell-selection for this to take effect.

pub fn select_header_style<S: Into<Style>>(self, select_style: S) -> Self

Style for a selected header cell. The chosen selection must support column-selection for this to take effect.

pub fn select_footer_style<S: Into<Style>>(self, select_style: S) -> Self

Style for a selected footer cell. The chosen selection must support column-selection for this to take effect.

pub fn focus_style<S: Into<Style>>(self, focus_style: S) -> Self

This style will be patched onto the selection to indicate that the widget has the input focus.

The selection must support some kind of selection for this to be effective.

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

Indicates that this widget has the input focus.

impl<'a, Selection> FTable<'a, Selection>

pub fn need_scroll(&self, area: Rect) -> (bool, bool)

Does this table need scrollbars? Returns (horizontal, vertical)

Trait Implementations

impl<'a, Selection: Debug> Debug for FTable<'a, Selection>

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

Formats the value using the given formatter.

impl<'a, Selection: Default> Default for FTable<'a, Selection>

fn default() -> FTable<'a, Selection>

Returns the “default value” for a type.

impl<'a, Selection> StatefulWidget for FTable<'a, Selection>

where Selection: TableSelection,

type State = FTableState<Selection>

State associated with the stateful widget.

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

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

impl<'a, Selection> Styled for FTable<'a, Selection>

type Item = FTable<'a, Selection>

fn style(&self) -> Style

Returns the style of the object.

fn set_style<S: Into<Style>>(self, style: S) -> Self::Item

Sets the style of the object.