egui_data_table/
lib.rs

1#![doc = include_str!("../README.md")]
2
3pub mod draw;
4pub mod viewer;
5
6pub use draw::{Renderer, Style};
7pub use viewer::{RowViewer, UiAction};
8
9/// You may want to sync egui version with this crate.
10pub extern crate egui;
11
12/* ---------------------------------------------------------------------------------------------- */
13/*                                           CORE CLASS                                           */
14/* ---------------------------------------------------------------------------------------------- */
15
16/// Prevents direct modification of `Vec`
17pub struct DataTable<R> {
18    /// Efficient row data storage
19    ///
20    /// XXX: If we use `VecDeque` here, it'd be more efficient when inserting new element
21    /// at the beginning of the list. However, it does not support `splice` method like
22    /// `Vec`, which results in extremely inefficient when there's multiple insertions.
23    ///
24    /// The efficiency order of general operations are only twice as slow when using
25    /// `Vec`, we're just ignoring it for now. Maybe we can utilize `IndexMap` for this
26    /// purpose, however, there are many trade-offs to consider, for now, we're just
27    /// using `Vec` for simplicity.
28    rows: Vec<R>,
29
30    dirty_flag: bool,
31
32    /// Ui
33    ui: Option<Box<draw::state::UiState<R>>>,
34}
35
36impl<R: std::fmt::Debug> std::fmt::Debug for DataTable<R> {
37    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
38        f.debug_struct("Spreadsheet")
39            .field("rows", &self.rows)
40            .finish()
41    }
42}
43
44impl<R> Default for DataTable<R> {
45    fn default() -> Self {
46        Self {
47            rows: Default::default(),
48            ui: Default::default(),
49            dirty_flag: false,
50        }
51    }
52}
53
54impl<R> FromIterator<R> for DataTable<R> {
55    fn from_iter<T: IntoIterator<Item = R>>(iter: T) -> Self {
56        Self {
57            rows: iter.into_iter().collect(),
58            ..Default::default()
59        }
60    }
61}
62
63impl<R> DataTable<R> {
64    pub fn new() -> Self {
65        Default::default()
66    }
67
68    pub fn take(&mut self) -> Vec<R> {
69        self.mark_dirty();
70        std::mem::take(&mut self.rows)
71    }
72
73    /// Replace the current data with the new one.
74    pub fn replace(&mut self, new: Vec<R>) -> Vec<R> {
75        self.mark_dirty();
76        std::mem::replace(&mut self.rows, new)
77    }
78
79    /// Insert a row at the specified index. This is thin wrapper of `Vec::retain` which provides
80    /// additional dirty flag optimization.
81    pub fn retain(&mut self, mut f: impl FnMut(&R) -> bool) {
82        let mut removed_any = false;
83        self.rows.retain(|row| {
84            let retain = f(row);
85            removed_any |= !retain;
86            retain
87        });
88
89        if removed_any {
90            self.mark_dirty();
91        }
92    }
93
94    /// Check if the UI is obsolete and needs to be re-rendered due to data changes.
95    pub fn is_dirty(&self) -> bool {
96        self.ui.as_ref().is_some_and(|ui| ui.cc_is_dirty())
97    }
98
99    #[deprecated(
100        since = "0.5.1",
101        note = "user-driven dirty flag clearance is redundant"
102    )]
103    pub fn clear_dirty_flag(&mut self) {
104        // This is intentionally became a no-op
105    }
106
107    fn mark_dirty(&mut self) {
108        let Some(state) = self.ui.as_mut() else {
109            return;
110        };
111
112        state.force_mark_dirty();
113    }
114
115    /// Returns true if there were any user-driven(triggered by UI) modifications.
116    pub fn has_user_modification(&self) -> bool {
117        self.dirty_flag
118    }
119
120    /// Clears the user-driven(triggered by UI) modification flag.
121    pub fn clear_user_modification_flag(&mut self) {
122        self.dirty_flag = false;
123    }
124}
125
126impl<R> Extend<R> for DataTable<R> {
127    /// Programmatic extend operation will invalidate the index table cache.
128    fn extend<T: IntoIterator<Item = R>>(&mut self, iter: T) {
129        // Invalidate the cache
130        self.ui = None;
131        self.rows.extend(iter);
132    }
133}
134
135fn default<T: Default>() -> T {
136    T::default()
137}
138
139impl<R> std::ops::Deref for DataTable<R> {
140    type Target = Vec<R>;
141
142    fn deref(&self) -> &Self::Target {
143        &self.rows
144    }
145}
146
147impl<R> std::ops::DerefMut for DataTable<R> {
148    fn deref_mut(&mut self) -> &mut Self::Target {
149        self.mark_dirty();
150        &mut self.rows
151    }
152}
153
154impl<R: Clone> Clone for DataTable<R> {
155    fn clone(&self) -> Self {
156        Self {
157            rows: self.rows.clone(),
158            // UI field is treated as cache.
159            ui: None,
160            dirty_flag: self.dirty_flag,
161        }
162    }
163}
egui_data_table/lib.rs

egui_data_table/
lib.rs
