1use crate::block::Block;
2use crate::mouse::MouseResult;
3use crate::undo_support::{TableUndoExt, UndoSupport, UndoWidgetId};
4use crate::{
5 MeasurableWidget, SizeConstraints, StatefulWidget, Widget, apply_style, clear_text_area,
6 set_style_area,
7};
8use ftui_core::event::{MouseButton, MouseEvent, MouseEventKind};
9use ftui_core::geometry::{Rect, Size};
10use ftui_layout::{Constraint, Flex};
11use ftui_render::buffer::Buffer;
12use ftui_render::cell::Cell;
13use ftui_render::frame::{Frame, HitId, HitRegion};
14use ftui_style::{
15 Style, TableEffectResolver, TableEffectScope, TableEffectTarget, TableSection, TableTheme,
16};
17use ftui_text::{Line, Span, Text};
18use std::any::Any;
19
20fn text_into_owned(text: Text<'_>) -> Text<'static> {
21 Text::from_lines(
22 text.into_iter()
23 .map(|line| Line::from_spans(line.into_iter().map(Span::into_owned))),
24 )
25}
26
27#[derive(Debug, Clone, Default)]
29pub struct Row {
30 cells: Vec<Text<'static>>,
31 height: u16,
32 style: Style,
33 bottom_margin: u16,
34}
35
36impl Row {
37 #[must_use]
39 pub fn new<'a>(cells: impl IntoIterator<Item = impl Into<Text<'a>>>) -> Self {
40 Self {
41 cells: cells
42 .into_iter()
43 .map(|c| text_into_owned(c.into()))
44 .collect(),
45 height: 1,
46 style: Style::default(),
47 bottom_margin: 0,
48 }
49 }
50
51 #[must_use]
56 pub fn height(mut self, height: u16) -> Self {
57 self.height = height.max(1);
58 self
59 }
60
61 #[must_use]
63 pub fn style(mut self, style: Style) -> Self {
64 self.style = style;
65 self
66 }
67
68 #[must_use]
70 pub fn bottom_margin(mut self, margin: u16) -> Self {
71 self.bottom_margin = margin;
72 self
73 }
74}
75
76#[derive(Debug, Clone, Default)]
78pub struct Table<'a> {
79 rows: Vec<Row>,
80 widths: Vec<Constraint>,
81 header: Option<Row>,
82 block: Option<Block<'a>>,
83 style: Style,
84 highlight_style: Style,
85 theme: TableTheme,
86 theme_phase: f32,
87 column_spacing: u16,
88 hit_id: Option<HitId>,
91 data_hash: Option<u64>,
93}
94
95impl<'a> Table<'a> {
96 #[must_use]
98 pub fn new(
99 rows: impl IntoIterator<Item = Row>,
100 widths: impl IntoIterator<Item = Constraint>,
101 ) -> Self {
102 let rows: Vec<Row> = rows.into_iter().collect();
103 let widths: Vec<Constraint> = widths.into_iter().collect();
104
105 Self {
106 rows,
107 widths,
108 header: None,
109 block: None,
110 style: Style::default(),
111 highlight_style: Style::default(),
112 theme: TableTheme::default(),
113 theme_phase: 0.0,
114 column_spacing: 1,
115 hit_id: None,
116 data_hash: None,
117 }
118 }
119
120 #[must_use]
127 pub fn data_hash(mut self, hash: u64) -> Self {
128 self.data_hash = Some(hash);
129 self
130 }
131
132 #[must_use]
134 pub fn header(mut self, header: Row) -> Self {
135 self.header = Some(header);
136 self
137 }
138
139 #[must_use]
141 pub fn block(mut self, block: Block<'a>) -> Self {
142 self.block = Some(block);
143 self
144 }
145
146 #[must_use]
148 pub fn style(mut self, style: Style) -> Self {
149 self.style = style;
150 self
151 }
152
153 #[must_use]
155 pub fn highlight_style(mut self, style: Style) -> Self {
156 self.highlight_style = style;
157 self
158 }
159
160 #[must_use]
162 pub fn theme(mut self, theme: TableTheme) -> Self {
163 self.theme = theme;
164 self
165 }
166
167 #[must_use]
171 pub fn theme_phase(mut self, phase: f32) -> Self {
172 self.theme_phase = phase;
173 self
174 }
175
176 #[must_use]
178 pub fn column_spacing(mut self, spacing: u16) -> Self {
179 self.column_spacing = spacing;
180 self
181 }
182
183 #[must_use]
189 pub fn hit_id(mut self, id: HitId) -> Self {
190 self.hit_id = Some(id);
191 self
192 }
193
194 fn filtered_and_sorted_indices(&self, state: &mut TableState) -> std::sync::Arc<[usize]> {
195 if let Some(hash) = self.data_hash
196 && let Some((cached_hash, cached_filter, cached_sort_col, cached_sort_asc, indices)) =
197 &state.cached_display_indices
198 && *cached_hash == hash
199 && *cached_filter == state.filter
200 && *cached_sort_col == state.sort_column
201 && *cached_sort_asc == state.sort_ascending
202 {
203 return std::sync::Arc::clone(indices);
204 }
205
206 let mut indices: Vec<usize> = (0..self.rows.len()).collect();
207
208 if !state.filter.trim().is_empty() {
210 let query = state.filter.trim().to_lowercase();
211 indices.retain(|&i| {
212 let row = &self.rows[i];
213 row.cells.iter().any(|cell| {
214 if let Some(line) = cell.lines().first()
217 && cell.lines().len() == 1
218 && line.spans().len() == 1
219 {
220 return crate::contains_ignore_case(&line.spans()[0].content, &query);
221 }
222 crate::contains_ignore_case(&cell.to_plain_text(), &query)
223 })
224 });
225 }
226
227 if let Some(col_idx) = state.sort_column {
229 use std::borrow::Cow;
230 let mut sort_keys: Vec<(usize, Cow<str>)> = indices
231 .iter()
232 .map(|&i| {
233 let cell_text = self.rows[i].cells.get(col_idx);
234 let key = match cell_text {
235 Some(text) => {
236 if let Some(line) = text.lines().first() {
238 if text.lines().len() == 1 && line.spans().len() == 1 {
239 Cow::Borrowed(line.spans()[0].content.as_ref())
240 } else {
241 Cow::Owned(text.to_plain_text())
242 }
243 } else {
244 Cow::Borrowed("")
245 }
246 }
247 None => Cow::Borrowed(""),
248 };
249 (i, key)
250 })
251 .collect();
252
253 if state.sort_ascending {
254 sort_keys.sort_unstable_by(|a, b| a.1.cmp(&b.1));
255 } else {
256 sort_keys.sort_unstable_by(|a, b| b.1.cmp(&a.1));
257 }
258
259 indices = sort_keys.into_iter().map(|(i, _)| i).collect();
260 }
261
262 let arc_indices: std::sync::Arc<[usize]> = indices.into();
263
264 if let Some(hash) = self.data_hash {
265 state.cached_display_indices = Some((
266 hash,
267 state.filter.clone(),
268 state.sort_column,
269 state.sort_ascending,
270 std::sync::Arc::clone(&arc_indices),
271 ));
272 }
273
274 arc_indices
275 }
276
277 fn requires_measurement(constraints: &[Constraint]) -> bool {
278 constraints.iter().any(|c| {
279 matches!(
280 c,
281 Constraint::FitContent | Constraint::FitContentBounded { .. } | Constraint::FitMin
282 )
283 })
284 }
285
286 fn compute_intrinsic_widths(rows: &[Row], header: Option<&Row>, col_count: usize) -> Vec<u16> {
287 if col_count == 0 {
288 return Vec::new();
289 }
290
291 let mut col_widths: Vec<u16> = vec![0; col_count];
292
293 if let Some(header) = header {
294 for (i, cell) in header.cells.iter().enumerate().take(col_count) {
295 let cell_width = cell
296 .lines()
297 .iter()
298 .take(header.height as usize)
299 .map(|l| l.width())
300 .max()
301 .unwrap_or(0)
302 .min(u16::MAX as usize) as u16;
303 col_widths[i] = col_widths[i].max(cell_width);
304 }
305 }
306
307 for row in rows {
308 for (i, cell) in row.cells.iter().enumerate().take(col_count) {
309 let cell_width = cell
310 .lines()
311 .iter()
312 .take(row.height as usize)
313 .map(|l| l.width())
314 .max()
315 .unwrap_or(0)
316 .min(u16::MAX as usize) as u16;
317 col_widths[i] = col_widths[i].max(cell_width);
318 }
319 }
320
321 col_widths
322 }
323}
324
325impl<'a> Widget for Table<'a> {
326 fn render(&self, area: Rect, frame: &mut Frame) {
327 let mut state = TableState::default();
328 StatefulWidget::render(self, area, frame, &mut state);
329 }
330}
331
332impl ftui_a11y::Accessible for Table<'_> {
333 fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
334 use ftui_a11y::node::{A11yNodeInfo, A11yRole};
335
336 let base_id = crate::a11y_node_id(area);
337 let row_count = self.rows.len();
338 let col_count = self.widths.len();
339
340 let title = self
341 .block
342 .as_ref()
343 .and_then(|b| b.title_text())
344 .unwrap_or_default();
345
346 let mut table_node = A11yNodeInfo::new(base_id, A11yRole::Table, area)
347 .with_description(format!("{row_count} rows, {col_count} columns"));
348 if !title.is_empty() {
349 table_node = table_node.with_name(title);
350 }
351
352 vec![table_node]
353 }
354}
355
356pub type CachedTableDisplayIndices = (u64, String, Option<usize>, bool, std::sync::Arc<[usize]>);
357
358#[derive(Debug, Clone, Default)]
360pub struct TableState {
361 #[allow(dead_code)]
363 undo_id: UndoWidgetId,
364 pub selected: Option<usize>,
366 pub hovered: Option<usize>,
368 pub offset: usize,
370 persistence_id: Option<String>,
373 pub sort_column: Option<usize>,
375 pub sort_ascending: bool,
377 pub filter: String,
379 coherence: ftui_layout::CoherenceCache,
381 #[doc(hidden)]
383 pub cached_display_indices: Option<CachedTableDisplayIndices>,
384 #[doc(hidden)]
386 pub cached_intrinsic_widths: Option<(u64, std::sync::Arc<[u16]>)>,
387}
388
389impl TableState {
390 pub fn select(&mut self, index: Option<usize>) {
392 self.selected = index;
393 }
394
395 #[must_use]
397 pub fn with_persistence_id(mut self, id: impl Into<String>) -> Self {
398 self.persistence_id = Some(id.into());
399 self
400 }
401
402 #[must_use = "use the persistence id (if any)"]
404 pub fn persistence_id(&self) -> Option<&str> {
405 self.persistence_id.as_deref()
406 }
407}
408
409#[derive(Clone, Debug, Default, PartialEq)]
418#[cfg_attr(
419 feature = "state-persistence",
420 derive(serde::Serialize, serde::Deserialize)
421)]
422pub struct TablePersistState {
423 pub selected: Option<usize>,
425 pub offset: usize,
427 pub sort_column: Option<usize>,
429 pub sort_ascending: bool,
431 pub filter: String,
433}
434
435impl crate::stateful::Stateful for TableState {
436 type State = TablePersistState;
437
438 fn state_key(&self) -> crate::stateful::StateKey {
439 crate::stateful::StateKey::new("Table", self.persistence_id.as_deref().unwrap_or("default"))
440 }
441
442 fn save_state(&self) -> TablePersistState {
443 TablePersistState {
444 selected: self.selected,
445 offset: self.offset,
446 sort_column: self.sort_column,
447 sort_ascending: self.sort_ascending,
448 filter: self.filter.clone(),
449 }
450 }
451
452 fn restore_state(&mut self, state: TablePersistState) {
453 self.selected = state.selected;
455 self.hovered = None;
456 self.offset = state.offset;
457 self.sort_column = state.sort_column;
458 self.sort_ascending = state.sort_ascending;
459 self.filter = state.filter;
460 }
461}
462
463#[derive(Debug, Clone)]
469pub struct TableStateSnapshot {
470 selected: Option<usize>,
471 offset: usize,
472 sort_column: Option<usize>,
473 sort_ascending: bool,
474 filter: String,
475}
476
477impl UndoSupport for TableState {
478 fn undo_widget_id(&self) -> UndoWidgetId {
479 self.undo_id
480 }
481
482 fn create_snapshot(&self) -> Box<dyn Any + Send> {
483 Box::new(TableStateSnapshot {
484 selected: self.selected,
485 offset: self.offset,
486 sort_column: self.sort_column,
487 sort_ascending: self.sort_ascending,
488 filter: self.filter.clone(),
489 })
490 }
491
492 fn restore_snapshot(&mut self, snapshot: &dyn Any) -> bool {
493 if let Some(snap) = snapshot.downcast_ref::<TableStateSnapshot>() {
494 self.selected = snap.selected;
495 self.hovered = None;
496 self.offset = snap.offset;
497 self.sort_column = snap.sort_column;
498 self.sort_ascending = snap.sort_ascending;
499 self.filter = snap.filter.clone();
500 true
501 } else {
502 false
503 }
504 }
505}
506
507impl TableUndoExt for TableState {
508 fn sort_state(&self) -> (Option<usize>, bool) {
509 (self.sort_column, self.sort_ascending)
510 }
511
512 fn set_sort_state(&mut self, column: Option<usize>, ascending: bool) {
513 self.sort_column = column;
514 self.sort_ascending = ascending;
515 }
516
517 fn filter_text(&self) -> &str {
518 &self.filter
519 }
520
521 fn set_filter_text(&mut self, filter: &str) {
522 self.filter = filter.to_string();
523 }
524}
525
526impl TableState {
527 #[must_use]
531 pub fn undo_id(&self) -> UndoWidgetId {
532 self.undo_id
533 }
534
535 #[must_use = "use the sort column (if any)"]
537 pub fn sort_column(&self) -> Option<usize> {
538 self.sort_column
539 }
540
541 #[must_use]
543 pub fn sort_ascending(&self) -> bool {
544 self.sort_ascending
545 }
546
547 pub fn set_sort(&mut self, column: Option<usize>, ascending: bool) {
549 self.sort_column = column;
550 self.sort_ascending = ascending;
551 }
552
553 #[must_use]
555 pub fn filter(&self) -> &str {
556 &self.filter
557 }
558
559 pub fn set_filter(&mut self, filter: impl Into<String>) {
561 self.filter = filter.into();
562 }
563
564 pub fn handle_mouse(
579 &mut self,
580 event: &MouseEvent,
581 hit: Option<(HitId, HitRegion, u64)>,
582 expected_id: HitId,
583 row_count: usize,
584 ) -> MouseResult {
585 match event.kind {
586 MouseEventKind::Down(MouseButton::Left) => {
587 if let Some((id, HitRegion::Content, data)) = hit
588 && id == expected_id
589 {
590 let index = data as usize;
591 if index < row_count {
592 if self.selected == Some(index) {
594 return MouseResult::Activated(index);
595 }
596 self.select(Some(index));
597 return MouseResult::Selected(index);
598 }
599 }
600 MouseResult::Ignored
601 }
602 MouseEventKind::Moved => {
603 if let Some((id, HitRegion::Content, data)) = hit
604 && id == expected_id
605 {
606 let index = data as usize;
607 if index < row_count {
608 let changed = self.hovered != Some(index);
609 self.hovered = Some(index);
610 return if changed {
611 MouseResult::HoverChanged
612 } else {
613 MouseResult::Ignored
614 };
615 }
616 }
617 if self.hovered.is_some() {
619 self.hovered = None;
620 MouseResult::HoverChanged
621 } else {
622 MouseResult::Ignored
623 }
624 }
625 MouseEventKind::ScrollUp => {
626 self.scroll_up(3);
627 MouseResult::Scrolled
628 }
629 MouseEventKind::ScrollDown => {
630 self.scroll_down(3, row_count);
631 MouseResult::Scrolled
632 }
633 _ => MouseResult::Ignored,
634 }
635 }
636
637 pub fn scroll_up(&mut self, rows: usize) {
639 self.offset = self.offset.saturating_sub(rows);
640 }
641
642 pub fn scroll_down(&mut self, rows: usize, row_count: usize) {
646 self.offset = self
647 .offset
648 .saturating_add(rows)
649 .min(row_count.saturating_sub(1));
650 }
651}
652
653impl<'a> StatefulWidget for Table<'a> {
654 type State = TableState;
655
656 fn render(&self, area: Rect, frame: &mut Frame, state: &mut Self::State) {
657 if frame.a11y_enabled() {
658 frame.push_a11y_nodes(ftui_a11y::Accessible::accessibility_nodes(self, area));
659 }
660 #[cfg(feature = "tracing")]
661 let _widget_span = tracing::debug_span!(
662 "widget_render",
663 widget = "Table",
664 x = area.x,
665 y = area.y,
666 w = area.width,
667 h = area.height
668 )
669 .entered();
670
671 if area.is_empty() {
672 return;
673 }
674
675 let apply_styling = frame.degradation.apply_styling();
676 let theme = &self.theme;
677 let effects_enabled = apply_styling && !theme.effects.is_empty();
678 let has_column_effects = effects_enabled && theme_has_column_effects(theme);
679 let effect_resolver = theme.effect_resolver();
680 let effects = if effects_enabled {
681 Some((&effect_resolver, self.theme_phase))
682 } else {
683 None
684 };
685
686 let table_area = match &self.block {
688 Some(b) => {
689 let mut block = b.clone();
690 if apply_styling {
691 block = block.border_style(theme.border);
692 }
693 block.render(area, frame);
694 block.inner(area)
695 }
696 None => area,
697 };
698
699 if table_area.is_empty() {
700 return;
701 }
702
703 frame.buffer.push_scissor(table_area);
706
707 let fill_style = if apply_styling {
710 self.style.merge(&theme.row)
711 } else {
712 Style::default()
713 };
714 clear_text_area(frame, table_area, fill_style);
715
716 let header_height = self
717 .header
718 .as_ref()
719 .map(|h| h.height.saturating_add(h.bottom_margin))
720 .unwrap_or(0);
721
722 if header_height > table_area.height {
723 frame.buffer.pop_scissor();
724 return;
725 }
726
727 let rows_height = table_area.height.saturating_sub(header_height);
729 let rows_top = table_area.y.saturating_add(header_height);
730 let rows_max_y = table_area.bottom();
731
732 let display_indices = self.filtered_and_sorted_indices(state);
734 let row_count = display_indices.len();
735
736 if row_count == 0 {
738 state.offset = 0;
739 } else {
740 state.offset = state.offset.min(row_count.saturating_sub(1));
741
742 let available_height = rows_height;
746 let mut accumulated = 0u16;
747 let mut bottom_offset = row_count.saturating_sub(1);
748 for i in (0..row_count).rev() {
749 let row = &self.rows[display_indices[i]];
750 let total_row_height = if i == row_count - 1 {
751 row.height
752 } else {
753 row.height.saturating_add(row.bottom_margin)
754 };
755
756 if total_row_height > available_height.saturating_sub(accumulated) {
757 break;
758 }
759
760 accumulated = accumulated.saturating_add(total_row_height);
761 bottom_offset = i;
762 }
763
764 state.offset = state.offset.min(bottom_offset);
765 }
766
767 if let Some(selected) = state.selected {
769 if display_indices.is_empty() {
770 state.selected = None;
771 } else if !display_indices.contains(&selected) {
772 state.selected = display_indices.first().copied();
773 }
774 }
775
776 if let Some(selected) = state.selected
778 && let Some(selected_display_idx) =
779 display_indices.iter().position(|&idx| idx == selected)
780 {
781 if selected_display_idx < state.offset {
782 state.offset = selected_display_idx;
783 } else {
784 let mut current_y = rows_top;
786 let max_y = rows_max_y;
787 let mut last_visible = state.offset;
788
789 for (i, &row_idx) in display_indices.iter().enumerate().skip(state.offset) {
790 let row = &self.rows[row_idx];
791 if row.height > max_y.saturating_sub(current_y) {
792 break;
793 }
794 current_y = current_y
795 .saturating_add(row.height)
796 .saturating_add(row.bottom_margin);
797 last_visible = i;
798 }
799
800 if selected_display_idx > last_visible {
801 let mut new_offset = selected_display_idx;
802 let mut accumulated_height: u16 = 0;
803 let available_height = rows_height;
804
805 for i in (0..=selected_display_idx).rev() {
806 let row = &self.rows[display_indices[i]];
807 let total_row_height = if i == selected_display_idx {
808 row.height
809 } else {
810 row.height.saturating_add(row.bottom_margin)
811 };
812
813 if total_row_height > available_height.saturating_sub(accumulated_height) {
814 if i == selected_display_idx {
815 new_offset = selected_display_idx;
816 } else {
817 new_offset = i + 1;
818 }
819 break;
820 }
821
822 accumulated_height = accumulated_height.saturating_add(total_row_height);
823 new_offset = i;
824 }
825 state.offset = new_offset;
826 }
827 }
828 }
829
830 #[cfg(feature = "tracing")]
831 let table_span = tracing::debug_span!(
832 "table.render",
833 total_rows = self.rows.len(),
834 visible_rows = row_count,
835 offset = state.offset,
836 viewport_height = rows_height,
837 rendered_rows = tracing::field::Empty,
838 );
839 #[cfg(feature = "tracing")]
840 let _table_span_guard = table_span.clone().entered();
841
842 let flex = Flex::horizontal()
844 .constraints(self.widths.clone())
845 .gap(self.column_spacing);
846
847 let intrinsic_col_widths = if Self::requires_measurement(&self.widths) {
848 if let Some(hash) = self.data_hash {
849 if let Some((cached_hash, ref widths)) = state.cached_intrinsic_widths
850 && cached_hash == hash
851 && widths.len() == self.widths.len()
852 {
853 widths.clone()
854 } else {
855 let widths: std::sync::Arc<[u16]> =
856 Self::compute_intrinsic_widths(&self.rows, None, self.widths.len()).into();
857 state.cached_intrinsic_widths = Some((hash, widths.clone()));
858 widths
859 }
860 } else {
861 Self::compute_intrinsic_widths(&self.rows, None, self.widths.len()).into()
862 }
863 } else {
864 std::sync::Arc::new([])
865 };
866
867 let column_rects = flex.split_with_measurer_stably(
869 Rect::new(table_area.x, table_area.y, table_area.width, 1),
870 |idx, _| {
871 let row_width = intrinsic_col_widths.get(idx).copied().unwrap_or(0);
873 let header_width = self
874 .header
875 .as_ref()
876 .and_then(|h| h.cells.get(idx))
877 .map(|c| c.width().min(u16::MAX as usize) as u16)
878 .unwrap_or(0);
879 ftui_layout::LayoutSizeHint::exact(row_width.max(header_width))
880 },
881 &mut state.coherence,
882 );
883
884 let mut y = table_area.y;
885 let max_y = table_area.bottom();
886 let divider_char = divider_char(self.block.as_ref());
887
888 if let Some(header) = &self.header {
890 if y >= max_y {
891 frame.buffer.pop_scissor();
892 return;
893 }
894 let row_area = Rect::new(table_area.x, y, table_area.width, header.height);
895 let divider_area = Rect::new(
897 table_area.x,
898 y,
899 table_area.width,
900 header.height.saturating_add(header.bottom_margin),
901 );
902
903 let header_style = if apply_styling {
904 let mut style = self.style;
905 style = theme.header.merge(&style);
906 header.style.merge(&style)
907 } else {
908 Style::default()
909 };
910
911 clear_text_area(frame, row_area, header_style);
912
913 if apply_styling && let Some((resolver, phase)) = effects {
914 for (col_idx, rect) in column_rects.iter().enumerate() {
915 let cell_area = Rect::new(rect.x, y, rect.width, header.height);
916 let scope = TableEffectScope {
917 section: TableSection::Header,
918 row: None,
919 column: Some(col_idx),
920 };
921 let style = resolver.resolve(header_style, scope, phase);
922 set_style_area(&mut frame.buffer, cell_area, style);
923 }
924 }
925
926 let divider_style = if apply_styling {
927 theme.divider.merge(&header_style)
928 } else {
929 Style::default()
930 };
931 draw_vertical_dividers(
932 &mut frame.buffer,
933 divider_area,
934 &column_rects,
935 divider_char,
936 divider_style,
937 );
938
939 render_row(
940 header,
941 &column_rects,
942 frame,
943 y,
944 header_style,
945 TableSection::Header,
946 None,
947 effects,
948 effects.is_some(),
949 );
950
951 if let Some(col) = state.sort_column
953 && col < column_rects.len()
954 {
955 let rect = column_rects[col];
956 let symbol = if state.sort_ascending { "▲" } else { "▼" };
957 let x = rect.right().saturating_sub(1);
959 if x >= rect.x {
960 crate::draw_text_span(frame, x, y, symbol, header_style, rect.right());
961 }
962 }
963
964 y = y
965 .saturating_add(header.height)
966 .saturating_add(header.bottom_margin);
967 }
968
969 if row_count == 0 {
971 #[cfg(feature = "tracing")]
972 table_span.record("rendered_rows", 0_u64);
973 frame.buffer.pop_scissor();
974 return;
975 }
976
977 let mut rendered_rows = 0usize;
978 for (i, &row_idx) in display_indices.iter().enumerate().skip(state.offset) {
979 if y >= max_y {
980 break;
981 }
982
983 let row = &self.rows[row_idx];
984 let is_selected = state.selected == Some(row_idx);
985 let is_hovered = state.hovered == Some(row_idx);
986 let row_area = Rect::new(table_area.x, y, table_area.width, row.height);
987 let divider_area = Rect::new(
989 table_area.x,
990 y,
991 table_area.width,
992 row.height.saturating_add(row.bottom_margin),
993 );
994
995 let row_style = if apply_styling {
996 let mut style = self.style;
998 let stripe = if i % 2 == 0 { theme.row } else { theme.row_alt };
1000 style = stripe.merge(&style);
1001 style = row.style.merge(&style);
1003 if is_selected {
1005 style = theme.row_selected.merge(&style);
1006 }
1007 if is_hovered {
1009 style = theme.row_hover.merge(&style);
1010 }
1011 if is_selected {
1013 style = self.highlight_style.merge(&style);
1014 }
1015 style
1016 } else {
1017 Style::default()
1018 };
1019
1020 clear_text_area(frame, row_area, row_style);
1021
1022 if apply_styling && let Some((resolver, phase)) = effects {
1023 if has_column_effects {
1024 for (col_idx, rect) in column_rects.iter().enumerate() {
1025 let cell_area = Rect::new(rect.x, y, rect.width, row.height);
1026 let scope = TableEffectScope {
1027 section: TableSection::Body,
1028 row: Some(i),
1029 column: Some(col_idx),
1030 };
1031 let style = resolver.resolve(row_style, scope, phase);
1032 set_style_area(&mut frame.buffer, cell_area, style);
1033 }
1034 } else {
1035 let scope = TableEffectScope::row(TableSection::Body, i);
1036 let style = resolver.resolve(row_style, scope, phase);
1037 set_style_area(&mut frame.buffer, row_area, style);
1038 }
1039 }
1040
1041 let divider_style = if apply_styling {
1042 theme.divider.merge(&row_style)
1043 } else {
1044 Style::default()
1045 };
1046 draw_vertical_dividers(
1047 &mut frame.buffer,
1048 divider_area,
1049 &column_rects,
1050 divider_char,
1051 divider_style,
1052 );
1053
1054 render_row(
1055 row,
1056 &column_rects,
1057 frame,
1058 y,
1059 row_style,
1060 TableSection::Body,
1061 Some(i),
1062 effects,
1063 has_column_effects,
1064 );
1065
1066 if let Some(id) = self.hit_id {
1068 frame.register_hit(row_area, id, HitRegion::Content, row_idx as u64);
1070 }
1071
1072 rendered_rows = rendered_rows.saturating_add(1);
1073 y = y
1074 .saturating_add(row.height)
1075 .saturating_add(row.bottom_margin);
1076 }
1077
1078 #[cfg(feature = "tracing")]
1079 table_span.record("rendered_rows", rendered_rows as u64);
1080 frame.buffer.pop_scissor();
1081 }
1082}
1083
1084#[allow(clippy::too_many_arguments)]
1085fn render_row(
1086 row: &Row,
1087 col_rects: &[Rect],
1088 frame: &mut Frame,
1089 y: u16,
1090 base_style: Style,
1091 section: TableSection,
1092 row_idx: Option<usize>,
1093 effects: Option<(&TableEffectResolver<'_>, f32)>,
1094 column_effects: bool,
1095) {
1096 let apply_styling = frame.degradation.apply_styling();
1097 let row_effect_base = if apply_styling {
1098 if let Some((resolver, phase)) = effects {
1099 if !column_effects {
1100 let scope = TableEffectScope {
1101 section,
1102 row: row_idx,
1103 column: None,
1104 };
1105 Some(resolver.resolve(base_style, scope, phase))
1106 } else {
1107 None
1108 }
1109 } else {
1110 None
1111 }
1112 } else {
1113 None
1114 };
1115
1116 for (col_idx, cell_text) in row.cells.iter().enumerate() {
1117 if col_idx >= col_rects.len() {
1118 break;
1119 }
1120 let rect = col_rects[col_idx];
1121 let cell_area = Rect::new(rect.x, y, rect.width, row.height);
1122 let scope = if effects.is_some() {
1123 Some(TableEffectScope {
1124 section,
1125 row: row_idx,
1126 column: if column_effects { Some(col_idx) } else { None },
1127 })
1128 } else {
1129 None
1130 };
1131 let column_effect_base = if apply_styling && column_effects {
1132 if let (Some((resolver, phase)), Some(scope)) = (effects, scope) {
1133 Some(resolver.resolve(base_style, scope, phase))
1134 } else {
1135 None
1136 }
1137 } else {
1138 None
1139 };
1140
1141 for (line_idx, line) in cell_text.lines().iter().enumerate() {
1142 if line_idx as u16 >= row.height {
1143 break;
1144 }
1145
1146 let mut x = cell_area.x;
1147 for span in line.spans() {
1148 let mut span_style = if apply_styling {
1150 match span.style {
1151 Some(s) => s.merge(&base_style),
1152 None => base_style,
1153 }
1154 } else {
1155 Style::default()
1156 };
1157
1158 if let (Some((resolver, phase)), Some(scope)) = (effects, scope) {
1159 if span.style.is_none() {
1160 if let Some(base_effect) = column_effect_base.or(row_effect_base) {
1161 span_style = base_effect;
1162 } else {
1163 span_style = resolver.resolve(span_style, scope, phase);
1164 }
1165 } else {
1166 span_style = resolver.resolve(span_style, scope, phase);
1167 }
1168 }
1169
1170 x = crate::draw_text_span_with_link(
1171 frame,
1172 x,
1173 cell_area.y.saturating_add(line_idx as u16),
1174 &span.content,
1175 span_style,
1176 cell_area.right(),
1177 span.link.as_deref(),
1178 );
1179 if x >= cell_area.right() {
1180 break;
1181 }
1182 }
1183 }
1184 }
1185}
1186
1187fn theme_has_column_effects(theme: &TableTheme) -> bool {
1188 theme.effects.iter().any(|rule| {
1189 matches!(
1190 rule.target,
1191 TableEffectTarget::Column(_) | TableEffectTarget::ColumnRange { .. }
1192 )
1193 })
1194}
1195
1196fn divider_char(block: Option<&Block<'_>>) -> char {
1197 block
1198 .map(|b| b.border_set().vertical)
1199 .unwrap_or(crate::borders::BorderSet::SQUARE.vertical)
1200}
1201
1202fn draw_vertical_dividers(
1203 buf: &mut Buffer,
1204 row_area: Rect,
1205 col_rects: &[Rect],
1206 divider_char: char,
1207 style: Style,
1208) {
1209 if col_rects.len() < 2 || row_area.is_empty() {
1210 return;
1211 }
1212
1213 for pair in col_rects.windows(2) {
1214 let left = pair[0];
1215 let right = pair[1];
1216 let gap = right.x.saturating_sub(left.right());
1217 if gap == 0 {
1218 continue;
1219 }
1220 let x = left.right();
1221 if x >= row_area.right() {
1222 continue;
1223 }
1224 let mut cell = Cell::from_char(divider_char);
1225 apply_style(&mut cell, style);
1226 for y in row_area.y..row_area.bottom() {
1227 buf.set_fast(x, y, cell);
1228 }
1229 }
1230}
1231
1232impl MeasurableWidget for Table<'_> {
1233 fn measure(&self, _available: Size) -> SizeConstraints {
1234 if self.rows.is_empty() && self.header.is_none() {
1235 return SizeConstraints::ZERO;
1236 }
1237
1238 let col_count = self.widths.len();
1239 if col_count == 0 {
1240 return SizeConstraints::ZERO;
1241 }
1242
1243 let row_widths = Self::compute_intrinsic_widths(&self.rows, None, col_count);
1244
1245 let separator_width = if col_count > 1 {
1247 ((col_count - 1) as u16).saturating_mul(self.column_spacing)
1248 } else {
1249 0
1250 };
1251
1252 let mut summed_col_width = 0u16;
1253 for (i, &r_w) in row_widths.iter().enumerate() {
1254 let h_w = self
1255 .header
1256 .as_ref()
1257 .and_then(|h| h.cells.get(i))
1258 .map(|c| c.width().min(u16::MAX as usize) as u16)
1259 .unwrap_or(0);
1260 summed_col_width = summed_col_width.saturating_add(r_w.max(h_w));
1261 }
1262
1263 let content_width = summed_col_width.saturating_add(separator_width);
1264
1265 let header_height = self
1268 .header
1269 .as_ref()
1270 .map(|h| h.height.saturating_add(h.bottom_margin))
1271 .unwrap_or(0);
1272
1273 let rows_height: u16 = self.rows.iter().fold(0u16, |acc, r| {
1274 acc.saturating_add(r.height.saturating_add(r.bottom_margin))
1275 });
1276
1277 let content_height = header_height.saturating_add(rows_height);
1278
1279 let (block_width, block_height) = self
1281 .block
1282 .as_ref()
1283 .map(|b| {
1284 let inner = b.inner(Rect::new(0, 0, 100, 100));
1285 let w_overhead = 100u16.saturating_sub(inner.width);
1286 let h_overhead = 100u16.saturating_sub(inner.height);
1287 (w_overhead, h_overhead)
1288 })
1289 .unwrap_or((0, 0));
1290
1291 let total_width = content_width.saturating_add(block_width);
1292 let total_height = content_height.saturating_add(block_height);
1293
1294 SizeConstraints {
1295 min: Size::new(
1296 (col_count as u16).saturating_add(block_width),
1297 header_height.max(1).saturating_add(block_height),
1298 ),
1299 preferred: Size::new(total_width, total_height),
1300 max: Some(Size::new(total_width, total_height)), }
1302 }
1303
1304 fn has_intrinsic_size(&self) -> bool {
1305 !self.rows.is_empty() || self.header.is_some()
1306 }
1307}
1308
1309#[cfg(test)]
1310mod tests {
1311 use super::*;
1312 use ftui_render::buffer::Buffer;
1313 use ftui_render::cell::PackedRgba;
1314 use ftui_render::grapheme_pool::GraphemePool;
1315 use ftui_text::{Line, Span};
1316 #[cfg(feature = "tracing")]
1317 use std::sync::{Arc, Mutex};
1318 #[cfg(feature = "tracing")]
1319 use tracing::Subscriber;
1320 #[cfg(feature = "tracing")]
1321 use tracing_subscriber::Layer;
1322 #[cfg(feature = "tracing")]
1323 use tracing_subscriber::layer::{Context, SubscriberExt};
1324
1325 fn cell_char(buf: &Buffer, x: u16, y: u16) -> Option<char> {
1326 buf.get(x, y).and_then(|c| c.content.as_char())
1327 }
1328
1329 fn cell_fg(buf: &Buffer, x: u16, y: u16) -> Option<PackedRgba> {
1330 buf.get(x, y).map(|c| c.fg)
1331 }
1332
1333 fn row_text(buf: &Buffer, y: u16) -> String {
1334 let width = buf.width();
1335 let mut actual = String::new();
1336 for x in 0..width {
1337 let ch = buf
1338 .get(x, y)
1339 .and_then(|cell| cell.content.as_char())
1340 .unwrap_or(' ');
1341 actual.push(ch);
1342 }
1343 actual.trim().to_string()
1344 }
1345
1346 fn raw_row_text(buf: &Buffer, y: u16) -> String {
1347 let width = buf.width();
1348 let mut actual = String::new();
1349 for x in 0..width {
1350 let ch = buf
1351 .get(x, y)
1352 .and_then(|cell| cell.content.as_char())
1353 .unwrap_or(' ');
1354 actual.push(ch);
1355 }
1356 actual
1357 }
1358
1359 #[cfg(feature = "tracing")]
1360 #[derive(Debug, Default)]
1361 struct TableTraceState {
1362 span_count: usize,
1363 has_total_rows_field: bool,
1364 has_rendered_rows_field: bool,
1365 total_rows: Vec<u64>,
1366 rendered_rows: Vec<u64>,
1367 }
1368
1369 #[cfg(feature = "tracing")]
1370 struct TableTraceCapture {
1371 state: Arc<Mutex<TableTraceState>>,
1372 }
1373
1374 #[cfg(feature = "tracing")]
1375 #[derive(Default)]
1376 struct TableRenderVisitor {
1377 total_rows: Option<u64>,
1378 rendered_rows: Option<u64>,
1379 }
1380
1381 #[cfg(feature = "tracing")]
1382 impl tracing::field::Visit for TableRenderVisitor {
1383 fn record_u64(&mut self, field: &tracing::field::Field, value: u64) {
1384 match field.name() {
1385 "total_rows" => self.total_rows = Some(value),
1386 "rendered_rows" => self.rendered_rows = Some(value),
1387 _ => {}
1388 }
1389 }
1390
1391 fn record_i64(&mut self, field: &tracing::field::Field, value: i64) {
1392 if let Ok(value) = u64::try_from(value) {
1393 self.record_u64(field, value);
1394 }
1395 }
1396
1397 fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
1398 let value = format!("{value:?}");
1399 if let Ok(parsed) = value.parse::<u64>() {
1400 self.record_u64(field, parsed);
1401 }
1402 }
1403 }
1404
1405 #[cfg(feature = "tracing")]
1406 impl<S> Layer<S> for TableTraceCapture
1407 where
1408 S: Subscriber + for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>,
1409 {
1410 fn on_new_span(
1411 &self,
1412 attrs: &tracing::span::Attributes<'_>,
1413 _id: &tracing::Id,
1414 _ctx: Context<'_, S>,
1415 ) {
1416 if attrs.metadata().name() != "table.render" {
1417 return;
1418 }
1419
1420 let mut visitor = TableRenderVisitor::default();
1421 attrs.record(&mut visitor);
1422 let fields = attrs.metadata().fields();
1423
1424 let mut state = self.state.lock().expect("table trace state lock");
1425 state.span_count += 1;
1426 state.has_total_rows_field |= fields.field("total_rows").is_some();
1427 state.has_rendered_rows_field |= fields.field("rendered_rows").is_some();
1428 if let Some(total_rows) = visitor.total_rows {
1429 state.total_rows.push(total_rows);
1430 }
1431 if let Some(rendered_rows) = visitor.rendered_rows {
1432 state.rendered_rows.push(rendered_rows);
1433 }
1434 }
1435
1436 fn on_record(
1437 &self,
1438 id: &tracing::Id,
1439 values: &tracing::span::Record<'_>,
1440 ctx: Context<'_, S>,
1441 ) {
1442 let Some(span_ref) = ctx.span(id) else {
1443 return;
1444 };
1445 if span_ref.metadata().name() != "table.render" {
1446 return;
1447 }
1448
1449 let mut visitor = TableRenderVisitor::default();
1450 values.record(&mut visitor);
1451
1452 let mut state = self.state.lock().expect("table trace state lock");
1453 if let Some(total_rows) = visitor.total_rows {
1454 state.total_rows.push(total_rows);
1455 }
1456 if let Some(rendered_rows) = visitor.rendered_rows {
1457 state.rendered_rows.push(rendered_rows);
1458 }
1459 }
1460 }
1461
1462 #[test]
1465 fn row_new_from_strings() {
1466 let row = Row::new(["A", "B", "C"]);
1467 assert_eq!(row.cells.len(), 3);
1468 assert_eq!(row.height, 1);
1469 assert_eq!(row.bottom_margin, 0);
1470 }
1471
1472 #[test]
1473 fn row_builder_methods() {
1474 let row = Row::new(["X"])
1475 .height(3)
1476 .bottom_margin(1)
1477 .style(Style::new().bold());
1478 assert_eq!(row.height, 3);
1479 assert_eq!(row.bottom_margin, 1);
1480 assert!(row.style.has_attr(ftui_style::StyleFlags::BOLD));
1481 }
1482
1483 #[test]
1484 fn row_height_zero_clamps_to_one() {
1485 let row = Row::new(["X"]).height(0);
1486 assert_eq!(row.height, 1);
1487 }
1488
1489 #[test]
1492 fn table_state_default() {
1493 let state = TableState::default();
1494 assert_eq!(state.selected, None);
1495 assert_eq!(state.offset, 0);
1496 }
1497
1498 #[test]
1499 fn table_state_select() {
1500 let mut state = TableState::default();
1501 state.select(Some(5));
1502 assert_eq!(state.selected, Some(5));
1503 assert_eq!(state.offset, 0);
1504 }
1505
1506 #[test]
1507 fn table_state_deselect_preserves_offset() {
1508 let mut state = TableState {
1509 offset: 10,
1510 ..Default::default()
1511 };
1512 state.select(Some(3));
1513 assert_eq!(state.selected, Some(3));
1514 state.select(None);
1515 assert_eq!(state.selected, None);
1516 assert_eq!(state.offset, 10);
1517 }
1518
1519 #[test]
1520 fn table_state_scroll_down_is_overflow_safe() {
1521 let mut state = TableState {
1523 offset: usize::MAX - 1,
1524 ..Default::default()
1525 };
1526 state.scroll_down(10, 100);
1527 assert_eq!(state.offset, 99);
1528 }
1529
1530 #[test]
1533 fn render_zero_area() {
1534 let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]);
1535 let area = Rect::new(0, 0, 0, 0);
1536 let mut pool = GraphemePool::new();
1537 let mut frame = Frame::new(1, 1, &mut pool);
1538 Widget::render(&table, area, &mut frame);
1539 }
1541
1542 #[test]
1543 fn render_empty_rows() {
1544 let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
1545 let area = Rect::new(0, 0, 10, 5);
1546 let mut pool = GraphemePool::new();
1547 let mut frame = Frame::new(10, 5, &mut pool);
1548 Widget::render(&table, area, &mut frame);
1549 }
1551
1552 #[test]
1553 fn render_empty_rows_clears_stale_viewport() {
1554 let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
1555 let area = Rect::new(0, 0, 10, 3);
1556 let mut pool = GraphemePool::new();
1557 let mut frame = Frame::new(10, 3, &mut pool);
1558 frame.buffer.fill(area, Cell::from_char('X'));
1559
1560 Widget::render(&table, area, &mut frame);
1561
1562 assert_eq!(raw_row_text(&frame.buffer, 0), " ");
1563 assert_eq!(raw_row_text(&frame.buffer, 1), " ");
1564 assert_eq!(raw_row_text(&frame.buffer, 2), " ");
1565 }
1566
1567 #[test]
1568 fn render_single_row_single_column() {
1569 let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
1570 let area = Rect::new(0, 0, 10, 3);
1571 let mut pool = GraphemePool::new();
1572 let mut frame = Frame::new(10, 3, &mut pool);
1573 Widget::render(&table, area, &mut frame);
1574
1575 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
1576 assert_eq!(cell_char(&frame.buffer, 1, 0), Some('e'));
1577 assert_eq!(cell_char(&frame.buffer, 4, 0), Some('o'));
1578 }
1579
1580 #[test]
1581 fn render_shorter_cell_clears_stale_suffix() {
1582 let area = Rect::new(0, 0, 10, 1);
1583 let mut pool = GraphemePool::new();
1584 let mut frame = Frame::new(10, 1, &mut pool);
1585
1586 let long = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
1587 Widget::render(&long, area, &mut frame);
1588
1589 let short = Table::new([Row::new(["Hi"])], [Constraint::Fixed(10)]);
1590 Widget::render(&short, area, &mut frame);
1591
1592 assert_eq!(raw_row_text(&frame.buffer, 0), "Hi ");
1593 }
1594
1595 #[test]
1596 fn render_multiple_rows() {
1597 let table = Table::new(
1598 [Row::new(["AA", "BB"]), Row::new(["CC", "DD"])],
1599 [Constraint::Fixed(4), Constraint::Fixed(4)],
1600 );
1601 let area = Rect::new(0, 0, 10, 3);
1602 let mut pool = GraphemePool::new();
1603 let mut frame = Frame::new(10, 3, &mut pool);
1604 Widget::render(&table, area, &mut frame);
1605
1606 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1608 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('C'));
1610 }
1611
1612 #[test]
1613 fn render_with_header() {
1614 let header = Row::new(["Name", "Val"]);
1615 let table = Table::new(
1616 [Row::new(["foo", "42"])],
1617 [Constraint::Fixed(5), Constraint::Fixed(4)],
1618 )
1619 .header(header);
1620
1621 let area = Rect::new(0, 0, 10, 3);
1622 let mut pool = GraphemePool::new();
1623 let mut frame = Frame::new(10, 3, &mut pool);
1624 Widget::render(&table, area, &mut frame);
1625
1626 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('N'));
1628 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('f'));
1630 }
1631
1632 #[test]
1633 fn render_shorter_header_clears_stale_suffix() {
1634 let area = Rect::new(0, 0, 10, 2);
1635 let mut pool = GraphemePool::new();
1636 let mut frame = Frame::new(10, 2, &mut pool);
1637
1638 let long =
1639 Table::new([Row::new(["row"])], [Constraint::Fixed(10)]).header(Row::new(["Header"]));
1640 Widget::render(&long, area, &mut frame);
1641
1642 let short =
1643 Table::new([Row::new(["row"])], [Constraint::Fixed(10)]).header(Row::new(["H"]));
1644 Widget::render(&short, area, &mut frame);
1645
1646 assert_eq!(raw_row_text(&frame.buffer, 0), "H ");
1647 }
1648
1649 #[test]
1650 fn zero_height_row_clamps_and_preserves_vertical_flow() {
1651 let table = Table::new(
1652 [Row::new(["A"]).height(0), Row::new(["B"])],
1653 [Constraint::Fixed(3)],
1654 );
1655 let area = Rect::new(0, 0, 3, 2);
1656 let mut pool = GraphemePool::new();
1657 let mut frame = Frame::new(3, 2, &mut pool);
1658 Widget::render(&table, area, &mut frame);
1659
1660 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1661 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
1662 }
1663
1664 #[test]
1665 fn zero_height_header_clamps_to_one_and_offsets_rows() {
1666 let header = Row::new(["H"]).height(0);
1667 let table = Table::new([Row::new(["D"])], [Constraint::Fixed(3)]).header(header);
1668
1669 let area = Rect::new(0, 0, 3, 2);
1670 let mut pool = GraphemePool::new();
1671 let mut frame = Frame::new(3, 2, &mut pool);
1672 Widget::render(&table, area, &mut frame);
1673
1674 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
1675 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('D'));
1676 }
1677
1678 #[test]
1679 fn render_with_block() {
1680 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]).block(Block::bordered());
1681
1682 let area = Rect::new(0, 0, 10, 5);
1683 let mut pool = GraphemePool::new();
1684 let mut frame = Frame::new(10, 5, &mut pool);
1685 Widget::render(&table, area, &mut frame);
1686
1687 assert_eq!(cell_char(&frame.buffer, 2, 2), Some('X'));
1689 }
1690
1691 #[test]
1692 fn stateful_render_with_selection() {
1693 let table = Table::new(
1694 [Row::new(["A"]), Row::new(["B"]), Row::new(["C"])],
1695 [Constraint::Fixed(5)],
1696 )
1697 .highlight_style(Style::new().bold());
1698
1699 let area = Rect::new(0, 0, 5, 3);
1700 let mut pool = GraphemePool::new();
1701 let mut frame = Frame::new(5, 3, &mut pool);
1702 let mut state = TableState::default();
1703 state.select(Some(1));
1704
1705 StatefulWidget::render(&table, area, &mut frame, &mut state);
1706 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
1709 }
1710
1711 #[test]
1712 fn row_style_merge_precedence_and_span_override() {
1713 let base_fg = PackedRgba::rgb(10, 0, 0);
1714 let selected_fg = PackedRgba::rgb(20, 0, 0);
1715 let hovered_fg = PackedRgba::rgb(30, 0, 0);
1716 let table_fg = PackedRgba::rgb(40, 0, 0);
1717 let row_fg = PackedRgba::rgb(50, 0, 0);
1718 let highlight_fg = PackedRgba::rgb(60, 0, 0);
1719 let span_fg = PackedRgba::rgb(70, 0, 0);
1720
1721 let base_row = Style::new().fg(base_fg);
1722 let theme = TableTheme {
1723 row: base_row,
1724 row_alt: base_row,
1725 row_selected: Style::new().fg(selected_fg),
1726 row_hover: Style::new().fg(hovered_fg),
1727 ..Default::default()
1728 };
1729
1730 let text = Text::from_line(Line::from_spans([
1731 Span::raw("A"),
1732 Span::styled("B", Style::new().fg(span_fg)),
1733 ]));
1734
1735 let table = Table::new(
1736 [Row::new([text]).style(Style::new().fg(row_fg))],
1737 [Constraint::Fixed(2)],
1738 )
1739 .style(Style::new().fg(table_fg))
1740 .highlight_style(Style::new().fg(highlight_fg))
1741 .theme(theme);
1742
1743 let area = Rect::new(0, 0, 2, 1);
1744 let mut pool = GraphemePool::new();
1745 let mut frame = Frame::new(2, 1, &mut pool);
1746 let mut state = TableState {
1747 selected: Some(0),
1748 hovered: Some(0),
1749 ..Default::default()
1750 };
1751
1752 StatefulWidget::render(&table, area, &mut frame, &mut state);
1753
1754 assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(highlight_fg));
1755 assert_eq!(cell_fg(&frame.buffer, 1, 0), Some(span_fg));
1756 }
1757
1758 #[test]
1759 fn selection_below_offset_adjusts_offset() {
1760 let mut state = TableState {
1761 offset: 5,
1762 selected: Some(2), persistence_id: None,
1764 ..Default::default()
1765 };
1766
1767 let table = Table::new(
1768 (0..10).map(|i| Row::new([format!("Row {i}")])),
1769 [Constraint::Fixed(10)],
1770 );
1771 let area = Rect::new(0, 0, 10, 3);
1772 let mut pool = GraphemePool::new();
1773 let mut frame = Frame::new(10, 3, &mut pool);
1774 StatefulWidget::render(&table, area, &mut frame, &mut state);
1775
1776 assert_eq!(state.offset, 2);
1778 }
1779
1780 #[test]
1781 fn table_clamps_offset_to_fill_viewport_on_resize() {
1782 let rows: Vec<Row> = (0..10).map(|i| Row::new([format!("Row {i}")])).collect();
1783 let table = Table::new(rows, [Constraint::Min(10)]);
1784
1785 let mut pool = GraphemePool::new();
1786 let mut state = TableState {
1787 offset: 7,
1788 ..Default::default()
1789 };
1790
1791 let area_small = Rect::new(0, 0, 10, 3);
1793 let mut frame_small = Frame::new(10, 3, &mut pool);
1794 StatefulWidget::render(&table, area_small, &mut frame_small, &mut state);
1795 assert_eq!(state.offset, 7);
1796 assert_eq!(row_text(&frame_small.buffer, 0), "Row 7");
1797 assert_eq!(row_text(&frame_small.buffer, 2), "Row 9");
1798
1799 let area_large = Rect::new(0, 0, 10, 5);
1801 let mut frame_large = Frame::new(10, 5, &mut pool);
1802 StatefulWidget::render(&table, area_large, &mut frame_large, &mut state);
1803 assert_eq!(state.offset, 5);
1804 assert_eq!(row_text(&frame_large.buffer, 0), "Row 5");
1805 assert_eq!(row_text(&frame_large.buffer, 4), "Row 9");
1806 }
1807
1808 #[test]
1809 fn table_clamps_offset_to_fill_viewport_with_variable_row_heights() {
1810 let mut rows: Vec<Row> = (0..9).map(|i| Row::new([format!("Row {i}")])).collect();
1814 rows.push(Row::new(["Row 9"]).height(5));
1815 let table = Table::new(rows, [Constraint::Min(10)]);
1816
1817 let mut pool = GraphemePool::new();
1818 let mut state = TableState {
1819 offset: 9,
1820 ..Default::default()
1821 };
1822
1823 let area = Rect::new(0, 0, 10, 10);
1824 let mut frame = Frame::new(10, 10, &mut pool);
1825 StatefulWidget::render(&table, area, &mut frame, &mut state);
1826
1827 assert_eq!(state.offset, 4);
1828 assert_eq!(row_text(&frame.buffer, 0), "Row 4");
1829 }
1830
1831 #[test]
1832 fn selection_invalid_index_falls_back_to_first_row() {
1833 let table = Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(5)]);
1834 let area = Rect::new(0, 0, 5, 2);
1835 let mut pool = GraphemePool::new();
1836 let mut frame = Frame::new(5, 2, &mut pool);
1837 let mut state = TableState {
1838 offset: 0,
1839 selected: Some(99),
1840 persistence_id: None,
1841 ..Default::default()
1842 };
1843
1844 StatefulWidget::render(&table, area, &mut frame, &mut state);
1845 assert_eq!(state.selected, Some(0));
1846 }
1847
1848 #[test]
1849 fn selection_with_header_accounts_for_header_height() {
1850 let header = Row::new(["H"]);
1851 let table =
1852 Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(5)]).header(header);
1853
1854 let area = Rect::new(0, 0, 5, 2);
1855 let mut pool = GraphemePool::new();
1856 let mut frame = Frame::new(5, 2, &mut pool);
1857 let mut state = TableState {
1858 offset: 0,
1859 selected: Some(1),
1860 persistence_id: None,
1861 ..Default::default()
1862 };
1863
1864 StatefulWidget::render(&table, area, &mut frame, &mut state);
1865 assert_eq!(state.offset, 1);
1866 }
1867
1868 #[test]
1869 fn rows_overflow_area_truncated() {
1870 let table = Table::new(
1871 (0..20).map(|i| Row::new([format!("R{i}")])),
1872 [Constraint::Fixed(5)],
1873 );
1874 let area = Rect::new(0, 0, 5, 3);
1875 let mut pool = GraphemePool::new();
1876 let mut frame = Frame::new(5, 3, &mut pool);
1877 Widget::render(&table, area, &mut frame);
1878
1879 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('R'));
1881 assert_eq!(cell_char(&frame.buffer, 1, 0), Some('0'));
1882 assert_eq!(cell_char(&frame.buffer, 1, 2), Some('2'));
1883 }
1884
1885 #[test]
1886 fn column_spacing_applied() {
1887 let table = Table::new(
1888 [Row::new(["A", "B"])],
1889 [Constraint::Fixed(3), Constraint::Fixed(3)],
1890 )
1891 .column_spacing(2);
1892
1893 let area = Rect::new(0, 0, 10, 1);
1894 let mut pool = GraphemePool::new();
1895 let mut frame = Frame::new(10, 1, &mut pool);
1896 Widget::render(&table, area, &mut frame);
1897
1898 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1900 }
1901
1902 #[test]
1903 fn divider_style_overrides_row_style() {
1904 let row_fg = PackedRgba::rgb(120, 10, 10);
1905 let divider_fg = PackedRgba::rgb(0, 200, 0);
1906 let row_style = Style::new().fg(row_fg);
1907 let theme = TableTheme {
1908 row: row_style,
1909 row_alt: row_style,
1910 divider: Style::new().fg(divider_fg),
1911 ..Default::default()
1912 };
1913
1914 let table = Table::new(
1915 [Row::new(["AA", "BB"])],
1916 [Constraint::Fixed(2), Constraint::Fixed(2)],
1917 )
1918 .theme(theme);
1919
1920 let area = Rect::new(0, 0, 5, 1);
1921 let mut pool = GraphemePool::new();
1922 let mut frame = Frame::new(5, 1, &mut pool);
1923 Widget::render(&table, area, &mut frame);
1924
1925 assert_eq!(cell_fg(&frame.buffer, 2, 0), Some(divider_fg));
1926 }
1927
1928 #[test]
1929 fn block_border_uses_theme_border_style() {
1930 let border_fg = PackedRgba::rgb(1, 2, 3);
1931 let theme = TableTheme {
1932 border: Style::new().fg(border_fg),
1933 ..Default::default()
1934 };
1935
1936 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(1)])
1937 .block(Block::bordered())
1938 .theme(theme);
1939
1940 let area = Rect::new(0, 0, 3, 3);
1941 let mut pool = GraphemePool::new();
1942 let mut frame = Frame::new(3, 3, &mut pool);
1943 Widget::render(&table, area, &mut frame);
1944
1945 assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(border_fg));
1946 }
1947
1948 #[test]
1949 fn render_clips_long_cell_to_column_width() {
1950 let table = Table::new([Row::new(["ABCDE"])], [Constraint::Fixed(3)]);
1951 let area = Rect::new(0, 0, 3, 1);
1952 let mut pool = GraphemePool::new();
1953 let mut frame = Frame::new(4, 1, &mut pool);
1954 Widget::render(&table, area, &mut frame);
1955
1956 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1957 assert_eq!(cell_char(&frame.buffer, 1, 0), Some('B'));
1958 assert_eq!(cell_char(&frame.buffer, 2, 0), Some('C'));
1959 assert_ne!(cell_char(&frame.buffer, 3, 0), Some('D'));
1960 }
1961
1962 #[test]
1963 fn render_multiline_cell_respects_row_height() {
1964 let table = Table::new([Row::new(["A\nB"]).height(1)], [Constraint::Fixed(3)]);
1965 let area = Rect::new(0, 0, 3, 2);
1966 let mut pool = GraphemePool::new();
1967 let mut frame = Frame::new(3, 2, &mut pool);
1968 Widget::render(&table, area, &mut frame);
1969
1970 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1971 assert_ne!(cell_char(&frame.buffer, 0, 1), Some('B'));
1972 }
1973
1974 #[test]
1975 fn render_multiline_cell_draws_second_line_when_height_allows() {
1976 let table = Table::new([Row::new(["A\nB"]).height(2)], [Constraint::Fixed(3)]);
1977 let area = Rect::new(0, 0, 3, 2);
1978 let mut pool = GraphemePool::new();
1979 let mut frame = Frame::new(3, 2, &mut pool);
1980 Widget::render(&table, area, &mut frame);
1981
1982 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
1983 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
1984 }
1985
1986 #[test]
1987 fn more_cells_than_columns_truncated() {
1988 let table = Table::new(
1989 [Row::new(["A", "B", "C", "D"])],
1990 [Constraint::Fixed(3), Constraint::Fixed(3)],
1991 );
1992 let area = Rect::new(0, 0, 8, 1);
1993 let mut pool = GraphemePool::new();
1994 let mut frame = Frame::new(8, 1, &mut pool);
1995 Widget::render(&table, area, &mut frame);
1996 }
1998
1999 #[test]
2000 fn header_too_tall_for_area() {
2001 let header = Row::new(["H"]).height(10);
2002 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]).header(header);
2003
2004 let area = Rect::new(0, 0, 5, 3);
2005 let mut pool = GraphemePool::new();
2006 let mut frame = Frame::new(5, 3, &mut pool);
2007 Widget::render(&table, area, &mut frame);
2008 }
2010
2011 #[test]
2012 fn row_with_bottom_margin() {
2013 let table = Table::new(
2014 [Row::new(["A"]).bottom_margin(1), Row::new(["B"])],
2015 [Constraint::Fixed(5)],
2016 );
2017 let area = Rect::new(0, 0, 5, 4);
2018 let mut pool = GraphemePool::new();
2019 let mut frame = Frame::new(5, 4, &mut pool);
2020 Widget::render(&table, area, &mut frame);
2021
2022 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2024 assert_eq!(cell_char(&frame.buffer, 0, 2), Some('B'));
2025 }
2026
2027 #[test]
2028 fn table_registers_hit_regions() {
2029 let table = Table::new(
2030 [Row::new(["A"]), Row::new(["B"]), Row::new(["C"])],
2031 [Constraint::Fixed(5)],
2032 )
2033 .hit_id(HitId::new(99));
2034
2035 let area = Rect::new(0, 0, 5, 3);
2036 let mut pool = GraphemePool::new();
2037 let mut frame = Frame::with_hit_grid(5, 3, &mut pool);
2038 let mut state = TableState::default();
2039 StatefulWidget::render(&table, area, &mut frame, &mut state);
2040
2041 let hit0 = frame.hit_test(2, 0);
2043 let hit1 = frame.hit_test(2, 1);
2044 let hit2 = frame.hit_test(2, 2);
2045
2046 assert_eq!(hit0, Some((HitId::new(99), HitRegion::Content, 0)));
2047 assert_eq!(hit1, Some((HitId::new(99), HitRegion::Content, 1)));
2048 assert_eq!(hit2, Some((HitId::new(99), HitRegion::Content, 2)));
2049 }
2050
2051 #[test]
2052 fn table_no_hit_without_hit_id() {
2053 let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]);
2054 let area = Rect::new(0, 0, 5, 1);
2055 let mut pool = GraphemePool::new();
2056 let mut frame = Frame::with_hit_grid(5, 1, &mut pool);
2057 let mut state = TableState::default();
2058 StatefulWidget::render(&table, area, &mut frame, &mut state);
2059
2060 assert!(frame.hit_test(2, 0).is_none());
2062 }
2063
2064 #[test]
2065 fn table_no_hit_without_hit_grid() {
2066 let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]).hit_id(HitId::new(1));
2067 let area = Rect::new(0, 0, 5, 1);
2068 let mut pool = GraphemePool::new();
2069 let mut frame = Frame::new(5, 1, &mut pool); let mut state = TableState::default();
2071 StatefulWidget::render(&table, area, &mut frame, &mut state);
2072
2073 assert!(frame.hit_test(2, 0).is_none());
2075 }
2076
2077 #[test]
2080 fn measure_empty_table() {
2081 let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2082 let c = table.measure(Size::MAX);
2083 assert_eq!(c, SizeConstraints::ZERO);
2084 }
2085
2086 #[test]
2087 fn measure_empty_columns() {
2088 let table = Table::new([Row::new(["A"])], Vec::<Constraint>::new());
2089 let c = table.measure(Size::MAX);
2090 assert_eq!(c, SizeConstraints::ZERO);
2091 }
2092
2093 #[test]
2094 fn measure_single_row() {
2095 let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
2096 let c = table.measure(Size::MAX);
2097
2098 assert_eq!(c.preferred.width, 5); assert_eq!(c.preferred.height, 1); assert!(table.has_intrinsic_size());
2101 }
2102
2103 #[test]
2104 fn measure_multiple_columns() {
2105 let table = Table::new(
2106 [Row::new(["A", "BB", "CCC"])],
2107 [
2108 Constraint::Fixed(5),
2109 Constraint::Fixed(5),
2110 Constraint::Fixed(5),
2111 ],
2112 )
2113 .column_spacing(2);
2114
2115 let c = table.measure(Size::MAX);
2116
2117 assert_eq!(c.preferred.width, 10);
2119 assert_eq!(c.preferred.height, 1);
2120 }
2121
2122 #[test]
2123 fn measure_respects_row_height_and_column_spacing() {
2124 let table = Table::new(
2125 [Row::new(["A", "BB"]).height(2)],
2126 [Constraint::FitContent, Constraint::FitContent],
2127 )
2128 .column_spacing(2);
2129
2130 let c = table.measure(Size::MAX);
2131
2132 assert_eq!(c.preferred.width, 5);
2133 assert_eq!(c.preferred.height, 2);
2134 }
2135
2136 #[test]
2137 fn measure_accounts_for_wide_glyphs() {
2138 let table = Table::new(
2139 [Row::new(["界", "A"])],
2140 [Constraint::FitContent, Constraint::FitContent],
2141 )
2142 .column_spacing(1);
2143
2144 let c = table.measure(Size::MAX);
2145
2146 assert_eq!(c.preferred.width, 4);
2147 assert_eq!(c.preferred.height, 1);
2148 }
2149
2150 #[test]
2151 fn measure_with_header() {
2152 let header = Row::new(["Name", "Value"]);
2153 let table = Table::new(
2154 [Row::new(["foo", "42"])],
2155 [Constraint::Fixed(5), Constraint::Fixed(5)],
2156 )
2157 .header(header);
2158
2159 let c = table.measure(Size::MAX);
2160
2161 assert_eq!(c.preferred.width, 10);
2164 assert_eq!(c.preferred.height, 2);
2166 }
2167
2168 #[test]
2169 fn measure_with_row_margins() {
2170 let table = Table::new(
2171 [
2172 Row::new(["A"]).bottom_margin(2),
2173 Row::new(["B"]).bottom_margin(1),
2174 ],
2175 [Constraint::Fixed(5)],
2176 );
2177
2178 let c = table.measure(Size::MAX);
2179
2180 assert_eq!(c.preferred.height, 5);
2182 }
2183
2184 #[test]
2185 fn measure_column_widths_from_max_cell() {
2186 let table = Table::new(
2187 [Row::new(["A", "BB"]), Row::new(["CCC", "D"])],
2188 [Constraint::Fixed(5), Constraint::Fixed(5)],
2189 )
2190 .column_spacing(1);
2191
2192 let c = table.measure(Size::MAX);
2193
2194 assert_eq!(c.preferred.width, 6);
2198 assert_eq!(c.preferred.height, 2);
2199 }
2200
2201 #[test]
2202 fn measure_min_is_column_count() {
2203 let table = Table::new(
2204 [Row::new(["A", "B", "C"])],
2205 [
2206 Constraint::Fixed(5),
2207 Constraint::Fixed(5),
2208 Constraint::Fixed(5),
2209 ],
2210 );
2211
2212 let c = table.measure(Size::MAX);
2213
2214 assert_eq!(c.min.width, 3);
2216 assert_eq!(c.min.height, 1);
2217 }
2218
2219 #[test]
2220 fn measure_has_intrinsic_size() {
2221 let empty = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2222 assert!(!empty.has_intrinsic_size());
2223
2224 let with_rows = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]);
2225 assert!(with_rows.has_intrinsic_size());
2226
2227 let header_only =
2228 Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]).header(Row::new(["Header"]));
2229 assert!(header_only.has_intrinsic_size());
2230 }
2231
2232 use crate::stateful::Stateful;
2235
2236 #[test]
2237 fn table_state_with_persistence_id() {
2238 let state = TableState::default().with_persistence_id("my-table");
2239 assert_eq!(state.persistence_id(), Some("my-table"));
2240 }
2241
2242 #[test]
2243 fn table_state_default_no_persistence_id() {
2244 let state = TableState::default();
2245 assert_eq!(state.persistence_id(), None);
2246 }
2247
2248 #[test]
2249 fn table_state_save_restore_round_trip() {
2250 let mut state = TableState::default().with_persistence_id("test");
2251 state.select(Some(5));
2252 state.offset = 3;
2253 state.set_sort(Some(2), true);
2254 state.set_filter("search term");
2255
2256 let saved = state.save_state();
2257 assert_eq!(saved.selected, Some(5));
2258 assert_eq!(saved.offset, 3);
2259 assert_eq!(saved.sort_column, Some(2));
2260 assert!(saved.sort_ascending);
2261 assert_eq!(saved.filter, "search term");
2262
2263 state.select(None);
2265 state.offset = 0;
2266 state.set_sort(None, false);
2267 state.set_filter("");
2268 assert_eq!(state.selected, None);
2269 assert_eq!(state.offset, 0);
2270 assert_eq!(state.sort_column(), None);
2271 assert!(!state.sort_ascending());
2272 assert!(state.filter().is_empty());
2273
2274 state.restore_state(saved);
2276 assert_eq!(state.selected, Some(5));
2277 assert_eq!(state.offset, 3);
2278 assert_eq!(state.sort_column(), Some(2));
2279 assert!(state.sort_ascending());
2280 assert_eq!(state.filter(), "search term");
2281 }
2282
2283 #[test]
2284 fn table_state_key_uses_persistence_id() {
2285 let state = TableState::default().with_persistence_id("main-data-table");
2286 let key = state.state_key();
2287 assert_eq!(key.widget_type, "Table");
2288 assert_eq!(key.instance_id, "main-data-table");
2289 }
2290
2291 #[test]
2292 fn table_state_key_default_when_no_id() {
2293 let state = TableState::default();
2294 let key = state.state_key();
2295 assert_eq!(key.widget_type, "Table");
2296 assert_eq!(key.instance_id, "default");
2297 }
2298
2299 #[test]
2300 fn table_persist_state_default() {
2301 let persist = TablePersistState::default();
2302 assert_eq!(persist.selected, None);
2303 assert_eq!(persist.offset, 0);
2304 assert_eq!(persist.sort_column, None);
2305 assert!(!persist.sort_ascending);
2306 assert!(persist.filter.is_empty());
2307 }
2308
2309 #[test]
2314 fn table_state_undo_widget_id_unique() {
2315 let state1 = TableState::default();
2316 let state2 = TableState::default();
2317 assert_ne!(state1.undo_id(), state2.undo_id());
2318 }
2319
2320 #[test]
2321 fn table_state_undo_snapshot_and_restore() {
2322 let mut state = TableState::default();
2323 state.select(Some(5));
2324 state.offset = 2;
2325 state.set_sort(Some(1), false);
2326 state.set_filter("test filter");
2327
2328 let snapshot = state.create_snapshot();
2330
2331 state.select(Some(10));
2333 state.offset = 7;
2334 state.set_sort(Some(3), true);
2335 state.set_filter("new filter");
2336
2337 assert_eq!(state.selected, Some(10));
2338 assert_eq!(state.offset, 7);
2339 assert_eq!(state.sort_column(), Some(3));
2340 assert!(state.sort_ascending());
2341 assert_eq!(state.filter(), "new filter");
2342
2343 assert!(state.restore_snapshot(&*snapshot));
2345
2346 assert_eq!(state.selected, Some(5));
2348 assert_eq!(state.offset, 2);
2349 assert_eq!(state.sort_column(), Some(1));
2350 assert!(!state.sort_ascending());
2351 assert_eq!(state.filter(), "test filter");
2352 }
2353
2354 #[test]
2355 fn table_state_undo_ext_sort() {
2356 let mut state = TableState::default();
2357
2358 assert_eq!(state.sort_state(), (None, false));
2360
2361 state.set_sort_state(Some(2), true);
2363 assert_eq!(state.sort_state(), (Some(2), true));
2364
2365 state.set_sort_state(Some(0), false);
2367 assert_eq!(state.sort_state(), (Some(0), false));
2368 }
2369
2370 #[test]
2371 fn table_state_undo_ext_filter() {
2372 let mut state = TableState::default();
2373
2374 assert_eq!(state.filter_text(), "");
2376
2377 state.set_filter_text("search term");
2379 assert_eq!(state.filter_text(), "search term");
2380
2381 state.set_filter_text("");
2383 assert_eq!(state.filter_text(), "");
2384 }
2385
2386 #[test]
2387 fn table_state_restore_wrong_snapshot_type_fails() {
2388 use std::any::Any;
2389 let mut state = TableState::default();
2390 let wrong_snapshot: Box<dyn Any + Send> = Box::new(42i32);
2391 assert!(!state.restore_snapshot(&*wrong_snapshot));
2392 }
2393
2394 use crate::mouse::MouseResult;
2397 use ftui_core::event::{MouseButton, MouseEvent, MouseEventKind};
2398
2399 #[test]
2400 fn table_state_click_selects() {
2401 let mut state = TableState::default();
2402 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2403 let hit = Some((HitId::new(1), HitRegion::Content, 4u64));
2404 let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2405 assert_eq!(result, MouseResult::Selected(4));
2406 assert_eq!(state.selected, Some(4));
2407 }
2408
2409 #[test]
2410 fn table_state_second_click_activates() {
2411 let mut state = TableState::default();
2412 state.select(Some(4));
2413
2414 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2415 let hit = Some((HitId::new(1), HitRegion::Content, 4u64));
2416 let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2417 assert_eq!(result, MouseResult::Activated(4));
2418 assert_eq!(state.selected, Some(4));
2419 }
2420
2421 #[test]
2422 fn table_state_click_wrong_id_ignored() {
2423 let mut state = TableState::default();
2424 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2425 let hit = Some((HitId::new(99), HitRegion::Content, 4u64));
2426 let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2427 assert_eq!(result, MouseResult::Ignored);
2428 }
2429
2430 #[test]
2431 fn table_state_hover_updates() {
2432 let mut state = TableState::default();
2433 let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2434 let hit = Some((HitId::new(1), HitRegion::Content, 3u64));
2435 let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2436 assert_eq!(result, MouseResult::HoverChanged);
2437 assert_eq!(state.hovered, Some(3));
2438 }
2439
2440 #[test]
2441 #[allow(clippy::field_reassign_with_default)]
2442 fn table_state_hover_same_index_ignored() {
2443 let mut state = {
2444 let mut s = TableState::default();
2445 s.hovered = Some(3);
2446 s
2447 };
2448 let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2449 let hit = Some((HitId::new(1), HitRegion::Content, 3u64));
2450 let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2451 assert_eq!(result, MouseResult::Ignored);
2452 assert_eq!(state.hovered, Some(3));
2453 }
2454
2455 #[test]
2456 #[allow(clippy::field_reassign_with_default)]
2457 fn table_state_hover_clears() {
2458 let mut state = {
2459 let mut s = TableState::default();
2460 s.hovered = Some(5);
2461 s
2462 };
2463 let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2464 let result = state.handle_mouse(&event, None, HitId::new(1), 10);
2466 assert_eq!(result, MouseResult::HoverChanged);
2467 assert_eq!(state.hovered, None);
2468 }
2469
2470 #[test]
2471 fn table_state_hover_clear_when_already_none() {
2472 let mut state = TableState::default();
2473 let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2474 let result = state.handle_mouse(&event, None, HitId::new(1), 10);
2475 assert_eq!(result, MouseResult::Ignored);
2476 }
2477
2478 #[test]
2479 #[allow(clippy::field_reassign_with_default)]
2480 fn table_state_scroll_wheel_up() {
2481 let mut state = {
2482 let mut s = TableState::default();
2483 s.offset = 10;
2484 s
2485 };
2486 let event = MouseEvent::new(MouseEventKind::ScrollUp, 0, 0);
2487 let result = state.handle_mouse(&event, None, HitId::new(1), 20);
2488 assert_eq!(result, MouseResult::Scrolled);
2489 assert_eq!(state.offset, 7);
2490 }
2491
2492 #[test]
2493 fn table_state_scroll_wheel_down() {
2494 let mut state = TableState::default();
2495 let event = MouseEvent::new(MouseEventKind::ScrollDown, 0, 0);
2496 let result = state.handle_mouse(&event, None, HitId::new(1), 20);
2497 assert_eq!(result, MouseResult::Scrolled);
2498 assert_eq!(state.offset, 3);
2499 }
2500
2501 #[test]
2502 #[allow(clippy::field_reassign_with_default)]
2503 fn table_state_scroll_down_clamps() {
2504 let mut state = {
2505 let mut s = TableState::default();
2506 s.offset = 18;
2507 s
2508 };
2509 state.scroll_down(5, 20);
2510 assert_eq!(state.offset, 19);
2511 }
2512
2513 #[test]
2514 #[allow(clippy::field_reassign_with_default)]
2515 fn table_state_scroll_up_clamps() {
2516 let mut state = {
2517 let mut s = TableState::default();
2518 s.offset = 1;
2519 s
2520 };
2521 state.scroll_up(5);
2522 assert_eq!(state.offset, 0);
2523 }
2524
2525 #[test]
2530 fn row_with_fewer_cells_than_columns() {
2531 let table = Table::new(
2533 [Row::new(["A"])],
2534 [
2535 Constraint::Fixed(3),
2536 Constraint::Fixed(3),
2537 Constraint::Fixed(3),
2538 ],
2539 );
2540 let area = Rect::new(0, 0, 12, 1);
2541 let mut pool = GraphemePool::new();
2542 let mut frame = Frame::new(12, 1, &mut pool);
2543 Widget::render(&table, area, &mut frame);
2544
2545 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2546 assert_ne!(cell_char(&frame.buffer, 4, 0), Some('A'));
2548 }
2549
2550 #[test]
2551 fn column_spacing_zero() {
2552 let table = Table::new(
2554 [Row::new(["AB", "CD"])],
2555 [Constraint::Fixed(2), Constraint::Fixed(2)],
2556 )
2557 .column_spacing(0);
2558
2559 let area = Rect::new(0, 0, 4, 1);
2560 let mut pool = GraphemePool::new();
2561 let mut frame = Frame::new(4, 1, &mut pool);
2562 Widget::render(&table, area, &mut frame);
2563
2564 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2565 assert_eq!(cell_char(&frame.buffer, 1, 0), Some('B'));
2566 assert_eq!(cell_char(&frame.buffer, 2, 0), Some('C'));
2567 assert_eq!(cell_char(&frame.buffer, 3, 0), Some('D'));
2568 }
2569
2570 #[test]
2571 fn render_with_nonzero_origin() {
2572 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)]);
2574 let area = Rect::new(5, 3, 3, 1);
2575 let mut pool = GraphemePool::new();
2576 let mut frame = Frame::new(10, 6, &mut pool);
2577 Widget::render(&table, area, &mut frame);
2578
2579 assert_eq!(cell_char(&frame.buffer, 5, 3), Some('X'));
2580 assert_ne!(cell_char(&frame.buffer, 0, 0), Some('X'));
2582 }
2583
2584 #[test]
2585 fn single_row_height_exceeds_area() {
2586 let table = Table::new([Row::new(["T"]).height(10)], [Constraint::Fixed(3)]);
2588 let area = Rect::new(0, 0, 3, 2);
2589 let mut pool = GraphemePool::new();
2590 let mut frame = Frame::new(3, 2, &mut pool);
2591 Widget::render(&table, area, &mut frame);
2592
2593 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('T'));
2595 }
2596
2597 #[test]
2598 fn selection_and_hover_on_same_row() {
2599 let selected_fg = PackedRgba::rgb(100, 0, 0);
2601 let hovered_fg = PackedRgba::rgb(0, 100, 0);
2602 let highlight_fg = PackedRgba::rgb(0, 0, 100);
2603
2604 let theme = TableTheme {
2605 row_selected: Style::new().fg(selected_fg),
2606 row_hover: Style::new().fg(hovered_fg),
2607 ..Default::default()
2608 };
2609
2610 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)])
2611 .highlight_style(Style::new().fg(highlight_fg))
2612 .theme(theme);
2613
2614 let area = Rect::new(0, 0, 3, 1);
2615 let mut pool = GraphemePool::new();
2616 let mut frame = Frame::new(3, 1, &mut pool);
2617 let mut state = TableState {
2618 selected: Some(0),
2619 hovered: Some(0),
2620 ..Default::default()
2621 };
2622
2623 StatefulWidget::render(&table, area, &mut frame, &mut state);
2624 assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(highlight_fg));
2626 }
2627
2628 #[test]
2629 fn alternating_row_styles() {
2630 let even_fg = PackedRgba::rgb(10, 10, 10);
2632 let odd_fg = PackedRgba::rgb(20, 20, 20);
2633 let theme = TableTheme {
2634 row: Style::new().fg(even_fg),
2635 row_alt: Style::new().fg(odd_fg),
2636 ..Default::default()
2637 };
2638
2639 let table = Table::new(
2640 [Row::new(["E"]), Row::new(["O"]), Row::new(["E2"])],
2641 [Constraint::Fixed(3)],
2642 )
2643 .theme(theme);
2644
2645 let area = Rect::new(0, 0, 3, 3);
2646 let mut pool = GraphemePool::new();
2647 let mut frame = Frame::new(3, 3, &mut pool);
2648 Widget::render(&table, area, &mut frame);
2649
2650 assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(even_fg));
2652 assert_eq!(cell_fg(&frame.buffer, 0, 1), Some(odd_fg));
2653 assert_eq!(cell_fg(&frame.buffer, 0, 2), Some(even_fg));
2654 }
2655
2656 #[test]
2657 fn scroll_up_from_zero_stays_zero() {
2658 let mut state = TableState::default();
2659 state.scroll_up(10);
2660 assert_eq!(state.offset, 0);
2661 }
2662
2663 #[test]
2664 fn scroll_down_with_zero_rows() {
2665 let mut state = TableState::default();
2666 state.scroll_down(5, 0);
2667 assert_eq!(state.offset, 0);
2668 }
2669
2670 #[test]
2671 fn scroll_down_with_single_row() {
2672 let mut state = TableState::default();
2673 state.scroll_down(5, 1);
2674 assert_eq!(state.offset, 0);
2675 }
2676
2677 #[test]
2678 fn mouse_click_on_row_exceeding_row_count() {
2679 let mut state = TableState::default();
2681 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
2682 let hit = Some((HitId::new(1), HitRegion::Content, 100u64));
2683 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
2684 assert_eq!(result, MouseResult::Ignored);
2685 assert_eq!(state.selected, None);
2686 }
2687
2688 #[test]
2689 fn mouse_right_click_ignored() {
2690 let mut state = TableState::default();
2691 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Right), 0, 0);
2692 let hit = Some((HitId::new(1), HitRegion::Content, 2u64));
2693 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
2694 assert_eq!(result, MouseResult::Ignored);
2695 }
2696
2697 #[test]
2698 fn mouse_hover_on_row_exceeding_row_count() {
2699 let mut state = TableState::default();
2700 let event = MouseEvent::new(MouseEventKind::Moved, 0, 0);
2701 let hit = Some((HitId::new(1), HitRegion::Content, 100u64));
2702 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
2703 assert_eq!(result, MouseResult::Ignored);
2705 assert_eq!(state.hovered, None);
2706 }
2707
2708 #[test]
2709 fn select_deselect_preserves_offset_then_reselect() {
2710 let mut state = TableState {
2711 offset: 15,
2712 ..Default::default()
2713 };
2714 state.select(Some(20));
2715 assert_eq!(state.selected, Some(20));
2716 assert_eq!(state.offset, 15); state.select(None);
2719 assert_eq!(state.offset, 15); state.select(Some(3));
2722 assert_eq!(state.selected, Some(3));
2723 assert_eq!(state.offset, 15); }
2725
2726 #[test]
2727 fn offset_clamped_when_rows_empty() {
2728 let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2729 let area = Rect::new(0, 0, 5, 3);
2730 let mut pool = GraphemePool::new();
2731 let mut frame = Frame::new(5, 3, &mut pool);
2732 let mut state = TableState {
2733 offset: 999,
2734 ..Default::default()
2735 };
2736 StatefulWidget::render(&table, area, &mut frame, &mut state);
2737 assert_eq!(state.offset, 0);
2738 }
2739
2740 #[test]
2741 fn selection_clamps_when_rows_empty() {
2742 let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2743 let area = Rect::new(0, 0, 5, 3);
2744 let mut pool = GraphemePool::new();
2745 let mut frame = Frame::new(5, 3, &mut pool);
2746 let mut state = TableState {
2747 selected: Some(5),
2748 ..Default::default()
2749 };
2750 StatefulWidget::render(&table, area, &mut frame, &mut state);
2751 assert_eq!(state.selected, None);
2752 }
2753
2754 #[test]
2755 fn header_with_bottom_margin_offsets_rows() {
2756 let header = Row::new(["H"]).bottom_margin(2);
2757 let table = Table::new([Row::new(["D"])], [Constraint::Fixed(3)]).header(header);
2758
2759 let area = Rect::new(0, 0, 3, 5);
2760 let mut pool = GraphemePool::new();
2761 let mut frame = Frame::new(3, 5, &mut pool);
2762 Widget::render(&table, area, &mut frame);
2763
2764 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
2766 assert_eq!(cell_char(&frame.buffer, 0, 3), Some('D'));
2767 }
2768
2769 #[test]
2770 fn block_plus_header_fill_entire_area() {
2771 let header = Row::new(["H"]);
2774 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)])
2775 .block(Block::bordered())
2776 .header(header);
2777
2778 let area = Rect::new(0, 0, 5, 5);
2779 let mut pool = GraphemePool::new();
2780 let mut frame = Frame::new(5, 5, &mut pool);
2781 Widget::render(&table, area, &mut frame);
2782
2783 assert_eq!(cell_char(&frame.buffer, 2, 2), Some('H'));
2785 let data_rendered =
2787 (0..5).any(|x| (0..5).any(|y| cell_char(&frame.buffer, x, y) == Some('X')));
2788 assert!(!data_rendered);
2789 }
2790
2791 #[test]
2792 fn min_constraint_measure() {
2793 let table = Table::new([Row::new(["AB"])], [Constraint::Min(10)]);
2794 let c = table.measure(Size::MAX);
2795 assert_eq!(c.preferred.width, 2);
2797 assert_eq!(c.preferred.height, 1);
2798 }
2799
2800 #[test]
2801 fn percentage_constraint_render() {
2802 let table = Table::new(
2804 [Row::new(["A", "B"])],
2805 [Constraint::Percentage(50.0), Constraint::Percentage(50.0)],
2806 );
2807 let area = Rect::new(0, 0, 20, 1);
2808 let mut pool = GraphemePool::new();
2809 let mut frame = Frame::new(20, 1, &mut pool);
2810 Widget::render(&table, area, &mut frame);
2811
2812 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2813 }
2814
2815 #[test]
2816 fn fit_content_constraint_measure() {
2817 let table = Table::new(
2818 [Row::new(["Hello", "World"])],
2819 [Constraint::FitContent, Constraint::FitContent],
2820 )
2821 .column_spacing(1);
2822
2823 let c = table.measure(Size::MAX);
2824 assert_eq!(c.preferred.width, 11);
2826 }
2827
2828 #[test]
2829 fn measure_with_block_adds_overhead() {
2830 let table_no_block = Table::new([Row::new(["X"])], [Constraint::Fixed(3)]);
2831 let table_with_block =
2832 Table::new([Row::new(["X"])], [Constraint::Fixed(3)]).block(Block::bordered());
2833
2834 let c_no = table_no_block.measure(Size::MAX);
2835 let c_with = table_with_block.measure(Size::MAX);
2836
2837 assert_eq!(c_with.preferred.width, c_no.preferred.width + 4);
2839 assert_eq!(c_with.preferred.height, c_no.preferred.height + 4);
2840 }
2841
2842 #[test]
2843 fn variable_height_rows_selection_scrolls_down() {
2844 let rows = vec![
2847 Row::new(["A"]),
2848 Row::new(["B"]),
2849 Row::new(["C"]).height(5),
2850 Row::new(["D"]),
2851 Row::new(["E"]),
2852 ];
2853 let table = Table::new(rows, [Constraint::Fixed(5)]);
2854 let area = Rect::new(0, 0, 5, 4);
2855 let mut pool = GraphemePool::new();
2856 let mut frame = Frame::new(5, 4, &mut pool);
2857 let mut state = TableState {
2858 selected: Some(4),
2859 ..Default::default()
2860 };
2861 StatefulWidget::render(&table, area, &mut frame, &mut state);
2862
2863 assert!(state.offset > 0);
2865 assert_eq!(state.selected, Some(4));
2866 }
2867
2868 #[test]
2869 fn many_rows_with_margins_viewport_clamping() {
2870 let rows: Vec<Row> = (0..20)
2873 .map(|i| Row::new([format!("R{i}")]).bottom_margin(1))
2874 .collect();
2875 let table = Table::new(rows, [Constraint::Fixed(5)]);
2876 let area = Rect::new(0, 0, 5, 5);
2877 let mut pool = GraphemePool::new();
2878 let mut frame = Frame::new(5, 5, &mut pool);
2879 let mut state = TableState {
2880 offset: 19,
2881 ..Default::default()
2882 };
2883 StatefulWidget::render(&table, area, &mut frame, &mut state);
2884
2885 assert!(state.offset < 19);
2887 }
2888
2889 #[test]
2890 fn render_area_width_one() {
2891 let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(5)]);
2893 let area = Rect::new(0, 0, 1, 1);
2894 let mut pool = GraphemePool::new();
2895 let mut frame = Frame::new(1, 1, &mut pool);
2896 Widget::render(&table, area, &mut frame);
2897
2898 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
2899 }
2900
2901 #[test]
2902 fn render_area_height_one() {
2903 let table = Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(3)]);
2905 let area = Rect::new(0, 0, 3, 1);
2906 let mut pool = GraphemePool::new();
2907 let mut frame = Frame::new(3, 1, &mut pool);
2908 Widget::render(&table, area, &mut frame);
2909
2910 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2911 }
2912
2913 #[test]
2914 fn hit_regions_with_offset() {
2915 let table = Table::new(
2917 (0..10).map(|i| Row::new([format!("R{i}")])),
2918 [Constraint::Fixed(5)],
2919 )
2920 .hit_id(HitId::new(42));
2921
2922 let area = Rect::new(0, 0, 5, 3);
2923 let mut pool = GraphemePool::new();
2924 let mut frame = Frame::with_hit_grid(5, 3, &mut pool);
2925 let mut state = TableState {
2926 offset: 5,
2927 ..Default::default()
2928 };
2929 StatefulWidget::render(&table, area, &mut frame, &mut state);
2930
2931 let hit0 = frame.hit_test(2, 0);
2933 assert_eq!(hit0, Some((HitId::new(42), HitRegion::Content, 5)));
2934
2935 let hit1 = frame.hit_test(2, 1);
2936 assert_eq!(hit1, Some((HitId::new(42), HitRegion::Content, 6)));
2937 }
2938
2939 #[test]
2940 fn table_state_sort_defaults() {
2941 let state = TableState::default();
2942 assert_eq!(state.sort_column(), None);
2943 assert!(!state.sort_ascending());
2944 assert!(state.filter().is_empty());
2945 }
2946
2947 #[test]
2948 fn table_state_set_sort_toggle() {
2949 let mut state = TableState::default();
2950 state.set_sort(Some(0), true);
2951 assert_eq!(state.sort_column(), Some(0));
2952 assert!(state.sort_ascending());
2953
2954 state.set_sort(Some(0), false);
2956 assert!(!state.sort_ascending());
2957
2958 state.set_sort(Some(3), true);
2960 assert_eq!(state.sort_column(), Some(3));
2961
2962 state.set_sort(None, false);
2964 assert_eq!(state.sort_column(), None);
2965 }
2966
2967 #[test]
2968 fn table_persist_round_trip_preserves_hovered_none() {
2969 let mut state = TableState::default().with_persistence_id("t");
2970 state.select(Some(3));
2971 state.hovered = Some(7);
2972 state.offset = 2;
2973
2974 let saved = state.save_state();
2975 state.restore_state(saved);
2976
2977 assert_eq!(state.hovered, None);
2979 assert_eq!(state.selected, Some(3));
2980 assert_eq!(state.offset, 2);
2981 }
2982
2983 #[test]
2984 fn undo_snapshot_clears_hovered() {
2985 let mut state = TableState::default();
2986 state.select(Some(2));
2987 state.hovered = Some(5);
2988
2989 let snap = state.create_snapshot();
2990
2991 state.select(Some(9));
2993 state.hovered = Some(8);
2994
2995 assert!(state.restore_snapshot(&*snap));
2997 assert_eq!(state.selected, Some(2));
2998 assert_eq!(state.hovered, None);
3000 }
3001
3002 #[test]
3003 fn wide_chars_in_render() {
3004 let table = Table::new([Row::new(["界界界"])], [Constraint::Fixed(4)]);
3007 let area = Rect::new(0, 0, 4, 1);
3008 let mut pool = GraphemePool::new();
3009 let mut frame = Frame::new(4, 1, &mut pool);
3010 Widget::render(&table, area, &mut frame);
3011
3012 let cell = frame.buffer.get(0, 0).unwrap();
3015 assert!(
3016 !cell.content.is_empty(),
3017 "first cell should contain CJK content, not be empty"
3018 );
3019 let cell1 = frame.buffer.get(1, 0).unwrap();
3021 assert!(
3022 cell1.content.is_continuation(),
3023 "second cell should be continuation of wide char"
3024 );
3025 }
3026
3027 #[test]
3028 fn empty_row_cells() {
3029 let table = Table::new(
3031 [Row::new(["", "", ""])],
3032 [
3033 Constraint::Fixed(3),
3034 Constraint::Fixed(3),
3035 Constraint::Fixed(3),
3036 ],
3037 );
3038 let area = Rect::new(0, 0, 11, 1);
3039 let mut pool = GraphemePool::new();
3040 let mut frame = Frame::new(11, 1, &mut pool);
3041 Widget::render(&table, area, &mut frame);
3042 }
3044
3045 #[test]
3046 fn measure_with_many_rows_saturates() {
3047 let rows: Vec<Row> = (0..10000).map(|_| Row::new(["X"]).height(100)).collect();
3049 let table = Table::new(rows, [Constraint::Fixed(3)]);
3050 let c = table.measure(Size::MAX);
3051
3052 assert!(c.preferred.height > 0);
3054 }
3055
3056 #[test]
3057 fn variable_height_rows_respect_viewport_visible_range() {
3058 let rows = vec![
3059 Row::new(["R0"]),
3060 Row::new(["R1"]).height(2),
3061 Row::new(["R2"]),
3062 Row::new(["R3"]),
3063 ];
3064 let table = Table::new(rows, [Constraint::Fixed(4)]);
3065 let area = Rect::new(0, 0, 4, 3);
3066 let mut pool = GraphemePool::new();
3067 let mut frame = Frame::new(4, 3, &mut pool);
3068 let mut state = TableState {
3069 offset: 1,
3070 ..Default::default()
3071 };
3072
3073 StatefulWidget::render(&table, area, &mut frame, &mut state);
3074
3075 assert_eq!(state.offset, 1);
3076 assert_eq!(row_text(&frame.buffer, 0), "R1");
3077 assert_eq!(row_text(&frame.buffer, 1), "");
3078 assert_eq!(row_text(&frame.buffer, 2), "R2");
3079 }
3080
3081 #[test]
3082 fn render_100k_rows_stays_within_8ms_frame_budget() {
3083 use std::time::{Duration, Instant};
3084
3085 let rows: Vec<Row> = (0..100_000).map(|_| Row::new(["row"])).collect();
3086 let table = Table::new(rows, [Constraint::Fixed(12)]);
3087 let area = Rect::new(0, 0, 12, 24);
3088 let mut state = TableState {
3089 offset: 50_000,
3090 ..Default::default()
3091 };
3092 let mut pool = GraphemePool::new();
3093
3094 let mut warmup = Frame::new(12, 24, &mut pool);
3096 StatefulWidget::render(&table, area, &mut warmup, &mut state);
3097
3098 let iterations = 20u32;
3099 let start = Instant::now();
3100 for _ in 0..iterations {
3101 let mut frame = Frame::new(12, 24, &mut pool);
3102 StatefulWidget::render(&table, area, &mut frame, &mut state);
3103 }
3104 let per_frame = start.elapsed() / iterations;
3105
3106 assert!(
3107 per_frame <= Duration::from_millis(8),
3108 "100k-row table render exceeded 8ms budget: {per_frame:?}"
3109 );
3110 }
3111
3112 #[cfg(feature = "tracing")]
3113 #[test]
3114 fn tracing_table_render_span_reports_row_counts() {
3115 let trace_state = Arc::new(Mutex::new(TableTraceState::default()));
3116 let _trace_test_guard = crate::tracing_test_support::acquire();
3117 let subscriber = tracing_subscriber::registry().with(TableTraceCapture {
3118 state: Arc::clone(&trace_state),
3119 });
3120 let _guard = tracing::subscriber::set_default(subscriber);
3121 tracing::callsite::rebuild_interest_cache();
3122
3123 let rows: Vec<Row> = (0..20).map(|i| Row::new([format!("R{i}")])).collect();
3124 let table = Table::new(rows, [Constraint::Fixed(6)]);
3125 let area = Rect::new(0, 0, 6, 4);
3126 let mut state = TableState {
3127 offset: 3,
3128 ..Default::default()
3129 };
3130 let mut pool = GraphemePool::new();
3131 let mut frame = Frame::new(6, 4, &mut pool);
3132 tracing::callsite::rebuild_interest_cache();
3135 StatefulWidget::render(&table, area, &mut frame, &mut state);
3136
3137 tracing::callsite::rebuild_interest_cache();
3138 let snapshot = trace_state.lock().expect("table trace state lock");
3139 assert!(
3140 snapshot.span_count >= 1,
3141 "expected at least one table.render span, got {}",
3142 snapshot.span_count
3143 );
3144 assert!(
3145 snapshot.has_total_rows_field,
3146 "table.render span missing total_rows field"
3147 );
3148 assert!(
3149 snapshot.has_rendered_rows_field,
3150 "table.render span missing rendered_rows field"
3151 );
3152 assert!(
3153 snapshot.total_rows.contains(&20),
3154 "expected total_rows=20 in span fields, got {:?}",
3155 snapshot.total_rows
3156 );
3157 assert!(
3158 snapshot.rendered_rows.iter().any(|&n| n > 0 && n <= 4),
3159 "expected rendered_rows between 1 and 4, got {:?}",
3160 snapshot.rendered_rows
3161 );
3162 }
3163}