rat-ftable2 0.4.0

ratatui table widget for large data
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

//!
//! Table-widget and row-editor.
//!

use ratatui_core::buffer::Buffer;
use ratatui_core::layout::Rect;

mod state;
mod widget;

pub use state::*;
pub use widget::*;

/// This trait renders the row-editor widgets.
///
/// It gets a slice of areas for all the cells in the table,
/// and renders all input widgets as it needs.
pub trait TableEditor<T> {
    /// State associated with the stateful widget.
    type State: TableEditorState<T>;

    /// Standard render call, but with added areas for each cell.
    /// The area is the area of the full row.
    fn render(
        &self, //
        area: Rect,
        cell_areas: &[Rect],
        buf: &mut Buffer,
        state: &mut Self::State,
    );
}

///
/// Trait for the editor widget state.
///
#[allow(unused_variables)]
pub trait TableEditorState<T> {
    /// Some external context.
    type Context<'a>;
    /// Error type.
    type Err;

    /// Create a fresh row value with all the defaults.
    fn create_value<'a>(&self, ctx: &'a Self::Context<'a>) -> Result<T, Self::Err>;

    /// Set the current row value for the editor.
    fn set_value<'a>(&mut self, value: T, ctx: &'a Self::Context<'a>) -> Result<(), Self::Err>;

    /// Return the current row value from the editor.
    /// None results will remove the table row.
    fn value<'a>(&mut self, ctx: &'a Self::Context<'a>) -> Result<Option<T>, Self::Err>;

    /// Returns the currently focused column.
    /// Used to scroll the column to fully visible.
    fn focused_col(&self) -> Option<usize> {
        None
    }

    /// Start editing the current value.
    /// If a specific column should be focused initially it is given as
    /// the column index.
    fn start<'a>(
        &mut self,
        col: Option<usize>,
        ctx: &'a Self::Context<'a>,
    ) -> Result<(), Self::Err> {
        Ok(())
    }

    /// Stop editing the current value.
    /// If necessary the editor can do some cleanup here.
    fn stop<'a>(&mut self, ctx: &'a Self::Context<'a>) -> Result<(), Self::Err> {
        Ok(())
    }
}

/// Editing mode.
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
pub enum Mode {
    #[default]
    View,
    Edit,
    Insert,
}