1use crate::block::{Alignment, 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, StyleSheet, TableEffectResolver, TableEffectScope, TableEffectTarget, TablePresetId,
16 TableSection, TableTheme,
17};
18use ftui_text::{Line, Span, Text};
19use std::any::Any;
20
21fn text_into_owned(text: Text<'_>) -> Text<'static> {
22 Text::from_lines(
23 text.into_iter()
24 .map(|line| Line::from_spans(line.into_iter().map(Span::into_owned))),
25 )
26}
27
28#[derive(Debug, Clone, Default)]
30pub struct Row {
31 cells: Vec<Text<'static>>,
32 height: u16,
33 style: Style,
34 bottom_margin: u16,
35}
36
37impl Row {
38 #[must_use]
40 pub fn new<'a>(cells: impl IntoIterator<Item = impl Into<Text<'a>>>) -> Self {
41 Self {
42 cells: cells
43 .into_iter()
44 .map(|c| text_into_owned(c.into()))
45 .collect(),
46 height: 1,
47 style: Style::default(),
48 bottom_margin: 0,
49 }
50 }
51
52 #[must_use]
57 pub fn height(mut self, height: u16) -> Self {
58 self.height = height.max(1);
59 self
60 }
61
62 #[must_use]
64 pub fn style(mut self, style: Style) -> Self {
65 self.style = style;
66 self
67 }
68
69 #[must_use]
71 pub fn bottom_margin(mut self, margin: u16) -> Self {
72 self.bottom_margin = margin;
73 self
74 }
75}
76
77#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
79pub enum Truncate {
80 #[default]
82 Clip,
83 Ellipsis,
85 Wrap,
87}
88
89#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
91pub struct ColumnSpec {
92 pub truncation: Truncate,
94 pub alignment: Alignment,
96}
97
98impl ColumnSpec {
99 #[must_use]
101 pub const fn new(truncation: Truncate, alignment: Alignment) -> Self {
102 Self {
103 truncation,
104 alignment,
105 }
106 }
107}
108
109#[derive(Debug, Clone, Default)]
111pub struct Table<'a> {
112 rows: Vec<Row>,
113 widths: Vec<Constraint>,
114 column_specs: Vec<ColumnSpec>,
115 header: Option<Row>,
116 block: Option<Block<'a>>,
117 style: Style,
118 highlight_style: Style,
119 theme: TableTheme,
120 theme_phase: f32,
121 column_spacing: Option<u16>,
122 cell_padding: Option<u8>,
123 use_theme_padding: bool,
124 hit_id: Option<HitId>,
127 data_hash: Option<u64>,
129}
130
131impl<'a> Table<'a> {
132 #[must_use]
134 pub fn new(
135 rows: impl IntoIterator<Item = Row>,
136 widths: impl IntoIterator<Item = Constraint>,
137 ) -> Self {
138 let rows: Vec<Row> = rows.into_iter().collect();
139 let widths: Vec<Constraint> = widths.into_iter().collect();
140
141 Self {
142 rows,
143 widths,
144 column_specs: Vec::new(),
145 header: None,
146 block: None,
147 style: Style::default(),
148 highlight_style: Style::default(),
149 theme: TableTheme::default(),
150 theme_phase: 0.0,
151 column_spacing: None,
152 cell_padding: None,
153 use_theme_padding: false,
154 hit_id: None,
155 data_hash: None,
156 }
157 }
158
159 #[must_use]
161 pub fn with_column_spec(mut self, col: usize, spec: ColumnSpec) -> Self {
162 if col >= self.column_specs.len() {
163 self.column_specs.resize(col + 1, ColumnSpec::default());
164 }
165 self.column_specs[col] = spec;
166 self
167 }
168
169 #[must_use]
171 pub fn with_column_truncation(mut self, col: usize, truncation: Truncate) -> Self {
172 if col >= self.column_specs.len() {
173 self.column_specs.resize(col + 1, ColumnSpec::default());
174 }
175 self.column_specs[col].truncation = truncation;
176 self
177 }
178
179 #[must_use]
181 pub fn with_column_alignment(mut self, col: usize, alignment: Alignment) -> Self {
182 if col >= self.column_specs.len() {
183 self.column_specs.resize(col + 1, ColumnSpec::default());
184 }
185 self.column_specs[col].alignment = alignment;
186 self
187 }
188
189 #[must_use]
196 pub fn data_hash(mut self, hash: u64) -> Self {
197 self.data_hash = Some(hash);
198 self
199 }
200
201 #[must_use]
203 pub fn header(mut self, header: Row) -> Self {
204 self.header = Some(header);
205 self
206 }
207
208 #[must_use]
210 pub fn block(mut self, block: Block<'a>) -> Self {
211 self.block = Some(block);
212 self
213 }
214
215 #[must_use]
217 pub fn style(mut self, style: Style) -> Self {
218 self.style = style;
219 self
220 }
221
222 #[must_use]
224 pub fn highlight_style(mut self, style: Style) -> Self {
225 self.highlight_style = style;
226 self
227 }
228
229 #[must_use]
231 pub fn theme(mut self, theme: TableTheme) -> Self {
232 self.theme = theme;
233 self
234 }
235
236 #[must_use]
238 pub const fn table_theme(&self) -> &TableTheme {
239 &self.theme
240 }
241
242 #[must_use]
248 pub fn with_stylesheet(self, sheet: &StyleSheet) -> Self {
249 self.with_stylesheet_prefix(sheet, crate::style_names::TABLE_PREFIX)
250 }
251
252 #[must_use]
258 pub fn with_stylesheet_prefix(mut self, sheet: &StyleSheet, prefix: &str) -> Self {
259 if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_BORDER)) {
260 self.theme.border = s;
261 }
262 if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_HEADER)) {
263 self.theme.header = s;
264 }
265 if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_ROW)) {
266 self.theme.row = s;
267 }
268 if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_ROW_ALT)) {
269 self.theme.row_alt = s;
270 }
271 if let Some(s) = sheet.get(&format!(
272 "{prefix}.{}",
273 crate::style_names::TABLE_ROW_SELECTED
274 )) {
275 self.theme.row_selected = s;
276 }
277 if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_ROW_HOVER)) {
278 self.theme.row_hover = s;
279 }
280 if let Some(s) = sheet.get(&format!("{prefix}.{}", crate::style_names::TABLE_DIVIDER)) {
281 self.theme.divider = s;
282 }
283 self
284 }
285
286 #[must_use]
290 pub fn theme_phase(mut self, phase: f32) -> Self {
291 self.theme_phase = phase;
292 self
293 }
294
295 #[must_use]
297 pub fn column_spacing(mut self, spacing: u16) -> Self {
298 self.column_spacing = Some(spacing);
299 self
300 }
301
302 #[must_use]
305 pub fn cell_padding(mut self, padding: u8) -> Self {
306 self.cell_padding = Some(padding);
307 self
308 }
309
310 #[must_use]
312 pub fn use_theme_padding(mut self, enabled: bool) -> Self {
313 self.use_theme_padding = enabled;
314 self
315 }
316
317 #[inline]
318 fn effective_column_spacing(&self) -> u16 {
319 self.column_spacing
320 .unwrap_or(u16::from(self.theme.column_gap))
321 }
322
323 #[inline]
324 fn effective_cell_padding(&self) -> u16 {
325 u16::from(self.cell_padding.unwrap_or(if self.use_theme_padding {
326 self.theme.padding
327 } else {
328 0
329 }))
330 }
331
332 #[must_use]
338 pub fn hit_id(mut self, id: HitId) -> Self {
339 self.hit_id = Some(id);
340 self
341 }
342
343 fn filtered_and_sorted_indices(&self, state: &mut TableState) -> std::sync::Arc<[usize]> {
344 if let Some(hash) = self.data_hash
345 && let Some((cached_hash, cached_filter, cached_sort_col, cached_sort_asc, indices)) =
346 &state.cached_display_indices
347 && *cached_hash == hash
348 && *cached_filter == state.filter
349 && *cached_sort_col == state.sort_column
350 && *cached_sort_asc == state.sort_ascending
351 {
352 return std::sync::Arc::clone(indices);
353 }
354
355 let mut indices: Vec<usize> = (0..self.rows.len()).collect();
356
357 if !state.filter.trim().is_empty() {
359 let query = state.filter.trim().to_lowercase();
360 indices.retain(|&i| {
361 let row = &self.rows[i];
362 row.cells.iter().any(|cell| {
363 if let Some(line) = cell.lines().first()
366 && cell.lines().len() == 1
367 && line.spans().len() == 1
368 {
369 return crate::contains_ignore_case(&line.spans()[0].content, &query);
370 }
371 crate::contains_ignore_case(&cell.to_plain_text(), &query)
372 })
373 });
374 }
375
376 if let Some(col_idx) = state.sort_column {
378 use std::borrow::Cow;
379 let mut sort_keys: Vec<(usize, Cow<str>)> = indices
380 .iter()
381 .map(|&i| {
382 let cell_text = self.rows[i].cells.get(col_idx);
383 let key = match cell_text {
384 Some(text) => {
385 if let Some(line) = text.lines().first() {
387 if text.lines().len() == 1 && line.spans().len() == 1 {
388 Cow::Borrowed(line.spans()[0].content.as_ref())
389 } else {
390 Cow::Owned(text.to_plain_text())
391 }
392 } else {
393 Cow::Borrowed("")
394 }
395 }
396 None => Cow::Borrowed(""),
397 };
398 (i, key)
399 })
400 .collect();
401
402 if state.sort_ascending {
403 sort_keys.sort_unstable_by(|a, b| a.1.cmp(&b.1));
404 } else {
405 sort_keys.sort_unstable_by(|a, b| b.1.cmp(&a.1));
406 }
407
408 indices = sort_keys.into_iter().map(|(i, _)| i).collect();
409 }
410
411 let arc_indices: std::sync::Arc<[usize]> = indices.into();
412
413 if let Some(hash) = self.data_hash {
414 state.cached_display_indices = Some((
415 hash,
416 state.filter.clone(),
417 state.sort_column,
418 state.sort_ascending,
419 std::sync::Arc::clone(&arc_indices),
420 ));
421 }
422
423 arc_indices
424 }
425
426 fn requires_measurement(constraints: &[Constraint]) -> bool {
427 constraints.iter().any(|c| {
428 matches!(
429 c,
430 Constraint::FitContent | Constraint::FitContentBounded { .. } | Constraint::FitMin
431 )
432 })
433 }
434
435 fn compute_intrinsic_widths(
436 rows: &[Row],
437 header: Option<&Row>,
438 col_count: usize,
439 cell_padding: u16,
440 ) -> Vec<u16> {
441 if col_count == 0 {
442 return Vec::new();
443 }
444
445 let pad_extra = cell_padding.saturating_mul(2);
446 let mut col_widths: Vec<u16> = vec![0; col_count];
447
448 if let Some(header) = header {
449 for (i, cell) in header.cells.iter().enumerate().take(col_count) {
450 let cell_width = (cell
451 .lines()
452 .iter()
453 .take(header.height as usize)
454 .map(|l| l.width())
455 .max()
456 .unwrap_or(0)
457 .min(u16::MAX as usize) as u16)
458 .saturating_add(pad_extra);
459 col_widths[i] = col_widths[i].max(cell_width);
460 }
461 }
462
463 for row in rows {
464 for (i, cell) in row.cells.iter().enumerate().take(col_count) {
465 let cell_width = (cell
466 .lines()
467 .iter()
468 .take(row.height as usize)
469 .map(|l| l.width())
470 .max()
471 .unwrap_or(0)
472 .min(u16::MAX as usize) as u16)
473 .saturating_add(pad_extra);
474 col_widths[i] = col_widths[i].max(cell_width);
475 }
476 }
477
478 col_widths
479 }
480}
481
482impl<'a> Widget for Table<'a> {
483 fn render(&self, area: Rect, frame: &mut Frame) {
484 let mut state = TableState::default();
485 StatefulWidget::render(self, area, frame, &mut state);
486 }
487}
488
489impl ftui_a11y::Accessible for Table<'_> {
490 fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
491 use ftui_a11y::node::{A11yNodeInfo, A11yRole};
492
493 let base_id = crate::a11y_node_id(area);
494 let row_count = self.rows.len();
495 let col_count = self.widths.len();
496
497 let title = self
498 .block
499 .as_ref()
500 .and_then(|b| b.title_text())
501 .unwrap_or_default();
502
503 let mut table_node = A11yNodeInfo::new(base_id, A11yRole::Table, area)
504 .with_description(format!("{row_count} rows, {col_count} columns"));
505 if !title.is_empty() {
506 table_node = table_node.with_name(title);
507 }
508
509 vec![table_node]
510 }
511}
512
513pub type CachedTableDisplayIndices = (u64, String, Option<usize>, bool, std::sync::Arc<[usize]>);
514
515#[derive(Debug, Clone, Default)]
517pub struct TableState {
518 #[allow(dead_code)]
520 undo_id: UndoWidgetId,
521 pub selected: Option<usize>,
523 pub hovered: Option<usize>,
525 pub offset: usize,
527 persistence_id: Option<String>,
530 pub sort_column: Option<usize>,
532 pub sort_ascending: bool,
534 pub filter: String,
536 coherence: ftui_layout::CoherenceCache,
538 #[doc(hidden)]
540 pub cached_display_indices: Option<CachedTableDisplayIndices>,
541 #[doc(hidden)]
543 pub cached_intrinsic_widths: Option<(u64, std::sync::Arc<[u16]>)>,
544}
545
546impl TableState {
547 pub fn select(&mut self, index: Option<usize>) {
549 self.selected = index;
550 }
551
552 #[must_use]
556 pub fn with_persistence_id(mut self, id: impl Into<String>) -> Self {
557 self.persistence_id = Some(id.into());
558 self
559 }
560
561 #[must_use = "use the persistence id (if any)"]
563 pub fn persistence_id(&self) -> Option<&str> {
564 self.persistence_id.as_deref()
565 }
566}
567
568#[derive(Clone, Debug, Default, PartialEq)]
577#[cfg_attr(
578 feature = "state-persistence",
579 derive(serde::Serialize, serde::Deserialize)
580)]
581pub struct TablePersistState {
582 pub selected: Option<usize>,
584 pub offset: usize,
586 pub sort_column: Option<usize>,
588 pub sort_ascending: bool,
590 pub filter: String,
592}
593
594impl crate::stateful::Stateful for TableState {
595 type State = TablePersistState;
596
597 fn state_key(&self) -> Option<crate::stateful::StateKey> {
598 self.persistence_id
600 .as_deref()
601 .map(|id| crate::stateful::StateKey::new("Table", id))
602 }
603
604 fn save_state(&self) -> TablePersistState {
605 TablePersistState {
606 selected: self.selected,
607 offset: self.offset,
608 sort_column: self.sort_column,
609 sort_ascending: self.sort_ascending,
610 filter: self.filter.clone(),
611 }
612 }
613
614 fn restore_state(&mut self, state: TablePersistState) {
615 self.selected = state.selected;
617 self.hovered = None;
618 self.offset = state.offset;
619 self.sort_column = state.sort_column;
620 self.sort_ascending = state.sort_ascending;
621 self.filter = state.filter;
622 }
623}
624
625#[derive(Debug, Clone)]
631pub struct TableStateSnapshot {
632 selected: Option<usize>,
633 offset: usize,
634 sort_column: Option<usize>,
635 sort_ascending: bool,
636 filter: String,
637}
638
639impl UndoSupport for TableState {
640 fn undo_widget_id(&self) -> UndoWidgetId {
641 self.undo_id
642 }
643
644 fn create_snapshot(&self) -> Box<dyn Any + Send> {
645 Box::new(TableStateSnapshot {
646 selected: self.selected,
647 offset: self.offset,
648 sort_column: self.sort_column,
649 sort_ascending: self.sort_ascending,
650 filter: self.filter.clone(),
651 })
652 }
653
654 fn restore_snapshot(&mut self, snapshot: &dyn Any) -> bool {
655 if let Some(snap) = snapshot.downcast_ref::<TableStateSnapshot>() {
656 self.selected = snap.selected;
657 self.hovered = None;
658 self.offset = snap.offset;
659 self.sort_column = snap.sort_column;
660 self.sort_ascending = snap.sort_ascending;
661 self.filter = snap.filter.clone();
662 true
663 } else {
664 false
665 }
666 }
667}
668
669impl TableUndoExt for TableState {
670 fn sort_state(&self) -> (Option<usize>, bool) {
671 (self.sort_column, self.sort_ascending)
672 }
673
674 fn set_sort_state(&mut self, column: Option<usize>, ascending: bool) {
675 self.sort_column = column;
676 self.sort_ascending = ascending;
677 }
678
679 fn filter_text(&self) -> &str {
680 &self.filter
681 }
682
683 fn set_filter_text(&mut self, filter: &str) {
684 self.filter = filter.to_string();
685 }
686}
687
688impl TableState {
689 #[must_use]
693 pub fn undo_id(&self) -> UndoWidgetId {
694 self.undo_id
695 }
696
697 #[must_use = "use the sort column (if any)"]
699 pub fn sort_column(&self) -> Option<usize> {
700 self.sort_column
701 }
702
703 #[must_use]
705 pub fn sort_ascending(&self) -> bool {
706 self.sort_ascending
707 }
708
709 pub fn set_sort(&mut self, column: Option<usize>, ascending: bool) {
711 self.sort_column = column;
712 self.sort_ascending = ascending;
713 }
714
715 #[must_use]
717 pub fn filter(&self) -> &str {
718 &self.filter
719 }
720
721 pub fn set_filter(&mut self, filter: impl Into<String>) {
723 self.filter = filter.into();
724 }
725
726 pub fn handle_mouse(
741 &mut self,
742 event: &MouseEvent,
743 hit: Option<(HitId, HitRegion, u64)>,
744 expected_id: HitId,
745 row_count: usize,
746 ) -> MouseResult {
747 match event.kind {
748 MouseEventKind::Down(MouseButton::Left) => {
749 if let Some((id, HitRegion::Content, data)) = hit
750 && id == expected_id
751 {
752 let index = data as usize;
753 if index < row_count {
754 if self.selected == Some(index) {
756 return MouseResult::Activated(index);
757 }
758 self.select(Some(index));
759 return MouseResult::Selected(index);
760 }
761 }
762 MouseResult::Ignored
763 }
764 MouseEventKind::Moved => {
765 if let Some((id, HitRegion::Content, data)) = hit
766 && id == expected_id
767 {
768 let index = data as usize;
769 if index < row_count {
770 let changed = self.hovered != Some(index);
771 self.hovered = Some(index);
772 return if changed {
773 MouseResult::HoverChanged
774 } else {
775 MouseResult::Ignored
776 };
777 }
778 }
779 if self.hovered.is_some() {
781 self.hovered = None;
782 MouseResult::HoverChanged
783 } else {
784 MouseResult::Ignored
785 }
786 }
787 MouseEventKind::ScrollUp => {
788 self.scroll_up(3);
789 MouseResult::Scrolled
790 }
791 MouseEventKind::ScrollDown => {
792 self.scroll_down(3, row_count);
793 MouseResult::Scrolled
794 }
795 _ => MouseResult::Ignored,
796 }
797 }
798
799 pub fn scroll_up(&mut self, rows: usize) {
801 self.offset = self.offset.saturating_sub(rows);
802 }
803
804 pub fn scroll_down(&mut self, rows: usize, row_count: usize) {
808 self.offset = self
809 .offset
810 .saturating_add(rows)
811 .min(row_count.saturating_sub(1));
812 }
813}
814
815impl<'a> StatefulWidget for Table<'a> {
816 type State = TableState;
817
818 fn render(&self, area: Rect, frame: &mut Frame, state: &mut Self::State) {
819 #[cfg(feature = "tracing")]
820 let _widget_span = tracing::debug_span!(
821 "widget_render",
822 widget = "Table",
823 x = area.x,
824 y = area.y,
825 w = area.width,
826 h = area.height
827 )
828 .entered();
829
830 if area.is_empty() {
831 return;
832 }
833
834 if frame.a11y_enabled() {
839 frame.push_a11y_nodes(ftui_a11y::Accessible::accessibility_nodes(self, area));
840 }
841
842 let apply_styling = frame.degradation.apply_styling();
843 let theme = &self.theme;
844 let effects_enabled = apply_styling && !theme.effects.is_empty();
845 let has_column_effects = effects_enabled && theme_has_column_effects(theme);
846 let effect_resolver = theme.effect_resolver();
847 let effects = if effects_enabled {
848 Some((&effect_resolver, self.theme_phase))
849 } else {
850 None
851 };
852
853 let table_area = match &self.block {
855 Some(b) => {
856 let mut block = b.clone();
857 if apply_styling {
858 block = block.border_style(theme.border);
859 }
860 crate::render_block_without_a11y(&block, area, frame);
861 block.inner(area)
862 }
863 None => area,
864 };
865
866 if table_area.is_empty() {
867 return;
868 }
869
870 frame.buffer.push_scissor(table_area);
873
874 let fill_style = if apply_styling {
877 self.style.merge(&theme.row)
878 } else {
879 Style::default()
880 };
881 clear_text_area(frame, table_area, fill_style);
882
883 let header_height = self
884 .header
885 .as_ref()
886 .map(|h| h.height.saturating_add(h.bottom_margin))
887 .unwrap_or(0);
888
889 if header_height > table_area.height {
890 frame.buffer.pop_scissor();
891 return;
892 }
893
894 let col_spacing = self.effective_column_spacing();
896 let cell_padding = self.effective_cell_padding();
897 let pad_extra = cell_padding.saturating_mul(2);
898 let flex = Flex::horizontal()
899 .constraints(self.widths.iter().copied())
900 .gap(col_spacing);
901
902 let intrinsic_col_widths: Option<std::sync::Arc<[u16]>> =
903 if Self::requires_measurement(&self.widths) {
904 if let Some(hash) = self.data_hash {
905 let cache_key = hash.rotate_left(8) ^ u64::from(cell_padding);
906 if let Some((cached_hash, ref widths)) = state.cached_intrinsic_widths
907 && cached_hash == cache_key
908 && widths.len() == self.widths.len()
909 {
910 Some(widths.clone())
911 } else {
912 let widths: std::sync::Arc<[u16]> = Self::compute_intrinsic_widths(
913 &self.rows,
914 None,
915 self.widths.len(),
916 cell_padding,
917 )
918 .into();
919 state.cached_intrinsic_widths = Some((cache_key, widths.clone()));
920 Some(widths)
921 }
922 } else {
923 Some(
924 Self::compute_intrinsic_widths(
925 &self.rows,
926 None,
927 self.widths.len(),
928 cell_padding,
929 )
930 .into(),
931 )
932 }
933 } else {
934 None
935 };
936
937 let arena = frame.arena();
938 let col_area = Rect::new(table_area.x, table_area.y, table_area.width, 1);
939 let measurer = |idx: usize, _: u16| {
940 let row_width = intrinsic_col_widths
941 .as_deref()
942 .and_then(|w| w.get(idx).copied())
943 .unwrap_or(0);
944 let header_width = self
945 .header
946 .as_ref()
947 .and_then(|h| h.cells.get(idx))
948 .map(|c| (c.width().min(u16::MAX as usize) as u16).saturating_add(pad_extra))
949 .unwrap_or(0);
950 ftui_layout::LayoutSizeHint::exact(row_width.max(header_width))
951 };
952
953 let column_rects_owned;
955 let column_rects: &[Rect] = if let Some(arena) = arena {
956 flex.split_with_measurer_stably_in(arena, col_area, measurer, &mut state.coherence)
957 } else {
958 column_rects_owned =
959 flex.split_with_measurer_stably(col_area, measurer, &mut state.coherence);
960 &column_rects_owned
961 };
962
963 let rows_height = table_area.height.saturating_sub(header_height);
965 let rows_top = table_area.y.saturating_add(header_height);
966 let rows_max_y = table_area.bottom();
967
968 let display_indices_owned;
970 let display_indices: &[usize] = if let Some(arena) = arena
971 && self.data_hash.is_none()
972 && state.filter.trim().is_empty()
973 && state.sort_column.is_none()
974 {
975 arena.alloc_iter(0..self.rows.len())
976 } else {
977 display_indices_owned = self.filtered_and_sorted_indices(state);
978 &display_indices_owned
979 };
980 let row_count = display_indices.len();
981
982 if row_count == 0 {
984 state.offset = 0;
985 } else {
986 state.offset = state.offset.min(row_count.saturating_sub(1));
987
988 let available_height = rows_height;
992 let mut accumulated = 0u16;
993 let mut bottom_offset = row_count.saturating_sub(1);
994 for i in (0..row_count).rev() {
995 let row = &self.rows[display_indices[i]];
996 let eff_h = effective_row_height(
997 row,
998 column_rects,
999 &self.column_specs,
1000 theme.row_height,
1001 cell_padding,
1002 );
1003 let total_row_height = if i == row_count - 1 {
1004 eff_h
1005 } else {
1006 eff_h.saturating_add(row.bottom_margin)
1007 };
1008
1009 if total_row_height > available_height.saturating_sub(accumulated) {
1010 break;
1011 }
1012
1013 accumulated = accumulated.saturating_add(total_row_height);
1014 bottom_offset = i;
1015 }
1016
1017 state.offset = state.offset.min(bottom_offset);
1018 }
1019
1020 if let Some(selected) = state.selected {
1022 if display_indices.is_empty() {
1023 state.selected = None;
1024 } else if !display_indices.contains(&selected) {
1025 state.selected = display_indices.first().copied();
1026 }
1027 }
1028
1029 if let Some(selected) = state.selected
1031 && let Some(selected_display_idx) =
1032 display_indices.iter().position(|&idx| idx == selected)
1033 {
1034 if selected_display_idx < state.offset {
1035 state.offset = selected_display_idx;
1036 } else {
1037 let mut current_y = rows_top;
1039 let max_y = rows_max_y;
1040 let mut last_visible = state.offset;
1041
1042 for (i, &row_idx) in display_indices.iter().enumerate().skip(state.offset) {
1043 let row = &self.rows[row_idx];
1044 let eff_h = effective_row_height(
1045 row,
1046 column_rects,
1047 &self.column_specs,
1048 theme.row_height,
1049 cell_padding,
1050 );
1051 if eff_h > max_y.saturating_sub(current_y) {
1052 break;
1053 }
1054 current_y = current_y
1055 .saturating_add(eff_h)
1056 .saturating_add(row.bottom_margin);
1057 last_visible = i;
1058 }
1059
1060 if selected_display_idx > last_visible {
1061 let mut new_offset = selected_display_idx;
1062 let mut accumulated_height: u16 = 0;
1063 let available_height = rows_height;
1064
1065 for i in (0..=selected_display_idx).rev() {
1066 let row = &self.rows[display_indices[i]];
1067 let eff_h = effective_row_height(
1068 row,
1069 column_rects,
1070 &self.column_specs,
1071 theme.row_height,
1072 cell_padding,
1073 );
1074 let total_row_height = if i == selected_display_idx {
1075 eff_h
1076 } else {
1077 eff_h.saturating_add(row.bottom_margin)
1078 };
1079
1080 if total_row_height > available_height.saturating_sub(accumulated_height) {
1081 if i == selected_display_idx {
1082 new_offset = selected_display_idx;
1083 } else {
1084 new_offset = i + 1;
1085 }
1086 break;
1087 }
1088
1089 accumulated_height = accumulated_height.saturating_add(total_row_height);
1090 new_offset = i;
1091 }
1092 state.offset = new_offset;
1093 }
1094 }
1095 }
1096
1097 #[cfg(feature = "tracing")]
1098 let table_span = tracing::debug_span!(
1099 "table.render",
1100 total_rows = self.rows.len(),
1101 visible_rows = row_count,
1102 offset = state.offset,
1103 viewport_height = rows_height,
1104 rendered_rows = tracing::field::Empty,
1105 );
1106 #[cfg(feature = "tracing")]
1107 let _table_span_guard = table_span.clone().entered();
1108
1109 let mut y = table_area.y;
1110 let max_y = table_area.bottom();
1111 let divider_char = divider_char(self.block.as_ref());
1112
1113 if let Some(header) = &self.header {
1115 if y >= max_y {
1116 frame.buffer.pop_scissor();
1117 return;
1118 }
1119 let row_area = Rect::new(table_area.x, y, table_area.width, header.height);
1120 let divider_area = Rect::new(
1122 table_area.x,
1123 y,
1124 table_area.width,
1125 header.height.saturating_add(header.bottom_margin),
1126 );
1127
1128 let header_style = if apply_styling {
1129 let mut style = self.style;
1130 style = theme.header.merge(&style);
1131 header.style.merge(&style)
1132 } else {
1133 Style::default()
1134 };
1135
1136 clear_text_area(frame, row_area, header_style);
1137
1138 if apply_styling && let Some((resolver, phase)) = effects {
1139 for (col_idx, rect) in column_rects.iter().enumerate() {
1140 let cell_area = Rect::new(rect.x, y, rect.width, header.height);
1141 let scope = TableEffectScope {
1142 section: TableSection::Header,
1143 row: None,
1144 column: Some(col_idx),
1145 };
1146 let style = resolver.resolve(header_style, scope, phase);
1147 set_style_area(&mut frame.buffer, cell_area, style);
1148 }
1149 }
1150
1151 let divider_style = if apply_styling {
1152 theme.divider.merge(&header_style)
1153 } else {
1154 Style::default()
1155 };
1156 draw_vertical_dividers(
1157 &mut frame.buffer,
1158 divider_area,
1159 column_rects,
1160 divider_char,
1161 divider_style,
1162 );
1163
1164 render_row(
1165 header,
1166 column_rects,
1167 frame,
1168 y,
1169 header_style,
1170 TableSection::Header,
1171 None,
1172 effects,
1173 effects.is_some(),
1174 &self.column_specs,
1175 header.height,
1176 theme.preset_id,
1177 cell_padding,
1178 );
1179
1180 if let Some(col) = state.sort_column
1182 && col < column_rects.len()
1183 {
1184 let rect = column_rects[col];
1185 let symbol = if state.sort_ascending { "▲" } else { "▼" };
1186 let right_edge = rect.right().saturating_sub(cell_padding);
1188 let x = right_edge.saturating_sub(1);
1189 if x >= rect.x.saturating_add(cell_padding) {
1190 crate::draw_text_span(frame, x, y, symbol, header_style, right_edge);
1191 }
1192 }
1193
1194 y = y
1195 .saturating_add(header.height)
1196 .saturating_add(header.bottom_margin);
1197 }
1198
1199 if row_count == 0 {
1201 #[cfg(feature = "tracing")]
1202 table_span.record("rendered_rows", 0_u64);
1203 frame.buffer.pop_scissor();
1204 return;
1205 }
1206
1207 let mut rendered_rows = 0usize;
1208 for (i, &row_idx) in display_indices.iter().enumerate().skip(state.offset) {
1209 if y >= max_y {
1210 break;
1211 }
1212
1213 let row = &self.rows[row_idx];
1214 let eff_height = effective_row_height(
1215 row,
1216 column_rects,
1217 &self.column_specs,
1218 theme.row_height,
1219 cell_padding,
1220 );
1221 let is_selected = state.selected == Some(row_idx);
1222 let is_hovered = state.hovered == Some(row_idx);
1223 let row_area = Rect::new(table_area.x, y, table_area.width, eff_height);
1224 let divider_area = Rect::new(
1226 table_area.x,
1227 y,
1228 table_area.width,
1229 eff_height.saturating_add(row.bottom_margin),
1230 );
1231
1232 let row_style = if apply_styling {
1233 let mut style = self.style;
1235 let stripe = if theme.stripe_period > 0
1237 && (i % (theme.stripe_period as usize)) == (theme.stripe_period as usize - 1)
1238 {
1239 theme.row_alt
1240 } else {
1241 theme.row
1242 };
1243 style = stripe.merge(&style);
1244 style = row.style.merge(&style);
1246 if is_hovered {
1248 style = theme.row_hover.merge(&style);
1249 }
1250 if is_selected {
1252 style = theme.row_selected.merge(&style);
1253 }
1254 if is_selected {
1256 style = self.highlight_style.merge(&style);
1257 }
1258 style
1259 } else {
1260 Style::default()
1261 };
1262
1263 clear_text_area(frame, row_area, row_style);
1264
1265 if apply_styling && let Some((resolver, phase)) = effects {
1266 if has_column_effects {
1267 for (col_idx, rect) in column_rects.iter().enumerate() {
1268 let cell_area = Rect::new(rect.x, y, rect.width, eff_height);
1269 let scope = TableEffectScope {
1270 section: TableSection::Body,
1271 row: Some(i),
1272 column: Some(col_idx),
1273 };
1274 let style = resolver.resolve(row_style, scope, phase);
1275 set_style_area(&mut frame.buffer, cell_area, style);
1276 }
1277 } else {
1278 let scope = TableEffectScope::row(TableSection::Body, i);
1279 let style = resolver.resolve(row_style, scope, phase);
1280 set_style_area(&mut frame.buffer, row_area, style);
1281 }
1282 }
1283
1284 let divider_style = if apply_styling {
1285 theme.divider.merge(&row_style)
1286 } else {
1287 Style::default()
1288 };
1289 draw_vertical_dividers(
1290 &mut frame.buffer,
1291 divider_area,
1292 column_rects,
1293 divider_char,
1294 divider_style,
1295 );
1296
1297 render_row(
1298 row,
1299 column_rects,
1300 frame,
1301 y,
1302 row_style,
1303 TableSection::Body,
1304 Some(i),
1305 effects,
1306 has_column_effects,
1307 &self.column_specs,
1308 eff_height,
1309 theme.preset_id,
1310 cell_padding,
1311 );
1312
1313 if let Some(id) = self.hit_id {
1315 frame.register_hit(row_area, id, HitRegion::Content, row_idx as u64);
1317 }
1318
1319 rendered_rows = rendered_rows.saturating_add(1);
1320 y = y
1321 .saturating_add(eff_height)
1322 .saturating_add(row.bottom_margin);
1323 }
1324
1325 #[cfg(feature = "tracing")]
1326 table_span.record("rendered_rows", rendered_rows as u64);
1327 frame.buffer.pop_scissor();
1328 }
1329}
1330
1331fn effective_row_height(
1334 row: &Row,
1335 col_rects: &[Rect],
1336 column_specs: &[ColumnSpec],
1337 theme_row_height: u8,
1338 cell_padding: u16,
1339) -> u16 {
1340 let mut h = row.height;
1341 let pad_total = cell_padding.saturating_mul(2);
1342 for (col_idx, cell) in row.cells.iter().enumerate() {
1343 let spec = column_specs.get(col_idx).copied().unwrap_or_default();
1344 if spec.truncation == Truncate::Wrap && col_idx < col_rects.len() {
1345 let col_w = col_rects[col_idx].width.saturating_sub(pad_total) as usize;
1346 if col_w > 0 {
1347 let mut cell_lines = 0usize;
1348 for line in cell.lines() {
1349 let wrapped = line.wrap(col_w, ftui_text::WrapMode::WordChar);
1350 cell_lines = cell_lines.saturating_add(wrapped.len().max(1));
1351 }
1352 h = h.max(cell_lines as u16);
1353 }
1354 }
1355 }
1356 let max_h = (theme_row_height as u16).max(row.height);
1357 h.min(max_h)
1358}
1359
1360#[allow(clippy::too_many_arguments)]
1361fn render_row(
1362 row: &Row,
1363 col_rects: &[Rect],
1364 frame: &mut Frame,
1365 y: u16,
1366 base_style: Style,
1367 section: TableSection,
1368 row_idx: Option<usize>,
1369 effects: Option<(&TableEffectResolver<'_>, f32)>,
1370 column_effects: bool,
1371 column_specs: &[ColumnSpec],
1372 rendered_height: u16,
1373 preset_id: Option<TablePresetId>,
1374 cell_padding: u16,
1375) {
1376 let apply_styling = frame.degradation.apply_styling();
1377 let row_effect_base = if apply_styling {
1378 if let Some((resolver, phase)) = effects {
1379 if !column_effects {
1380 let scope = TableEffectScope {
1381 section,
1382 row: row_idx,
1383 column: None,
1384 };
1385 Some(resolver.resolve(base_style, scope, phase))
1386 } else {
1387 None
1388 }
1389 } else {
1390 None
1391 }
1392 } else {
1393 None
1394 };
1395
1396 let is_ascii_theme = preset_id == Some(TablePresetId::TerminalClassic);
1397 let (ellipsis_str, ellipsis_width) = if is_ascii_theme {
1398 ("...", 3)
1399 } else {
1400 ("…", 1)
1401 };
1402 let pad_total = cell_padding.saturating_mul(2);
1403
1404 for (col_idx, cell_text) in row.cells.iter().enumerate() {
1405 if col_idx >= col_rects.len() {
1406 break;
1407 }
1408 let rect = col_rects[col_idx];
1409 if rect.width <= pad_total {
1410 continue;
1411 }
1412 let cell_area = Rect::new(
1413 rect.x.saturating_add(cell_padding),
1414 y,
1415 rect.width.saturating_sub(pad_total),
1416 rendered_height,
1417 );
1418 if cell_area.width == 0 {
1419 continue;
1420 }
1421 let scope = if effects.is_some() {
1422 Some(TableEffectScope {
1423 section,
1424 row: row_idx,
1425 column: if column_effects { Some(col_idx) } else { None },
1426 })
1427 } else {
1428 None
1429 };
1430 let column_effect_base = if apply_styling && column_effects {
1431 if let (Some((resolver, phase)), Some(scope)) = (effects, scope) {
1432 Some(resolver.resolve(base_style, scope, phase))
1433 } else {
1434 None
1435 }
1436 } else {
1437 None
1438 };
1439
1440 let spec = column_specs.get(col_idx).copied().unwrap_or_default();
1441 let max_w = cell_area.width as usize;
1442
1443 match spec.truncation {
1444 Truncate::Wrap => {
1445 let mut line_idx = 0usize;
1446 let max_lines = rendered_height as usize;
1447 for line in cell_text.lines() {
1448 if line_idx >= max_lines {
1449 break;
1450 }
1451 let wrapped = line.wrap(max_w, ftui_text::WrapMode::WordChar);
1452 if wrapped.is_empty() {
1453 line_idx += 1;
1454 } else {
1455 for wline in wrapped {
1456 if line_idx >= max_lines {
1457 break;
1458 }
1459 let line_width = wline
1460 .spans()
1461 .iter()
1462 .map(|s| ftui_core::text_width::display_width(&s.content))
1463 .sum::<usize>();
1464 render_cell_spans(
1465 wline.spans(),
1466 line_width,
1467 cell_area,
1468 cell_area.y.saturating_add(line_idx as u16),
1469 spec.alignment,
1470 apply_styling,
1471 base_style,
1472 effects,
1473 scope,
1474 column_effect_base,
1475 row_effect_base,
1476 frame,
1477 );
1478 line_idx += 1;
1479 }
1480 }
1481 }
1482 }
1483 Truncate::Ellipsis => {
1484 for (line_idx, line) in cell_text
1485 .lines()
1486 .iter()
1487 .take(rendered_height as usize)
1488 .enumerate()
1489 {
1490 let line_y = cell_area.y.saturating_add(line_idx as u16);
1491 let line_width = line
1492 .spans()
1493 .iter()
1494 .map(|s| ftui_core::text_width::display_width(&s.content))
1495 .sum::<usize>();
1496 if line_width <= max_w {
1497 render_cell_spans(
1498 line.spans(),
1499 line_width,
1500 cell_area,
1501 line_y,
1502 spec.alignment,
1503 apply_styling,
1504 base_style,
1505 effects,
1506 scope,
1507 column_effect_base,
1508 row_effect_base,
1509 frame,
1510 );
1511 } else if max_w <= ellipsis_width {
1512 let s = if is_ascii_theme {
1513 &ellipsis_str[..max_w.min(ellipsis_str.len())]
1514 } else if max_w >= 1 {
1515 "…"
1516 } else {
1517 ""
1518 };
1519 let spans = [Span::raw(s)];
1520 render_cell_spans(
1521 &spans,
1522 ftui_core::text_width::display_width(s),
1523 cell_area,
1524 line_y,
1525 spec.alignment,
1526 apply_styling,
1527 base_style,
1528 effects,
1529 scope,
1530 column_effect_base,
1531 row_effect_base,
1532 frame,
1533 );
1534 } else {
1535 let budget = max_w - ellipsis_width;
1536 let mut truncated_spans: ftui_layout::smallvec::SmallVec<[Span<'_>; 4]> =
1537 ftui_layout::smallvec::SmallVec::new();
1538 let mut used = 0usize;
1539 let mut hit_limit = false;
1540 for span in line.spans() {
1541 let content: &str = span.content.as_ref();
1542 let mut end_byte = 0usize;
1543 for (byte_idx, g) in
1544 unicode_segmentation::UnicodeSegmentation::grapheme_indices(
1545 content, true,
1546 )
1547 {
1548 let gw = ftui_core::text_width::grapheme_width(g);
1549 if gw == 0 {
1550 end_byte = byte_idx + g.len();
1551 continue;
1552 }
1553 if used + gw > budget {
1554 hit_limit = true;
1555 break;
1556 }
1557 end_byte = byte_idx + g.len();
1558 used += gw;
1559 }
1560 if end_byte > 0 {
1561 let mut s = Span::styled(
1562 &content[..end_byte],
1563 span.style.unwrap_or_default(),
1564 );
1565 s.link = span.link.clone();
1566 truncated_spans.push(s);
1567 }
1568 if hit_limit {
1569 break;
1570 }
1571 }
1572 let last_style = truncated_spans
1573 .last()
1574 .and_then(|s| s.style)
1575 .unwrap_or(base_style);
1576 truncated_spans.push(Span::styled(ellipsis_str, last_style));
1577 render_cell_spans(
1578 &truncated_spans,
1579 used + ellipsis_width,
1580 cell_area,
1581 line_y,
1582 spec.alignment,
1583 apply_styling,
1584 base_style,
1585 effects,
1586 scope,
1587 column_effect_base,
1588 row_effect_base,
1589 frame,
1590 );
1591 }
1592 }
1593 }
1594 Truncate::Clip => {
1595 for (line_idx, line) in cell_text
1596 .lines()
1597 .iter()
1598 .take(rendered_height as usize)
1599 .enumerate()
1600 {
1601 let line_width = line
1602 .spans()
1603 .iter()
1604 .map(|s| ftui_core::text_width::display_width(&s.content))
1605 .sum::<usize>();
1606 render_cell_spans(
1607 line.spans(),
1608 line_width,
1609 cell_area,
1610 cell_area.y.saturating_add(line_idx as u16),
1611 spec.alignment,
1612 apply_styling,
1613 base_style,
1614 effects,
1615 scope,
1616 column_effect_base,
1617 row_effect_base,
1618 frame,
1619 );
1620 }
1621 }
1622 }
1623 }
1624}
1625
1626#[allow(clippy::too_many_arguments)]
1627fn render_cell_spans(
1628 spans: &[Span<'_>],
1629 line_width: usize,
1630 cell_area: Rect,
1631 line_y: u16,
1632 alignment: Alignment,
1633 apply_styling: bool,
1634 base_style: Style,
1635 effects: Option<(&TableEffectResolver<'_>, f32)>,
1636 scope: Option<TableEffectScope>,
1637 column_effect_base: Option<Style>,
1638 row_effect_base: Option<Style>,
1639 frame: &mut Frame,
1640) {
1641 let left_offset = match alignment {
1642 Alignment::Left => 0,
1643 Alignment::Center => (cell_area.width as usize).saturating_sub(line_width) / 2,
1644 Alignment::Right => (cell_area.width as usize).saturating_sub(line_width),
1645 };
1646
1647 let mut x = cell_area.x.saturating_add(left_offset as u16);
1648
1649 for span in spans {
1650 let mut span_style = if apply_styling {
1651 match span.style {
1652 Some(s) => s.merge(&base_style),
1653 None => base_style,
1654 }
1655 } else {
1656 Style::default()
1657 };
1658
1659 if let (Some((resolver, phase)), Some(scope)) = (effects, scope) {
1660 if span.style.is_none() {
1661 if let Some(base_effect) = column_effect_base.or(row_effect_base) {
1662 span_style = base_effect;
1663 } else {
1664 span_style = resolver.resolve(span_style, scope, phase);
1665 }
1666 } else {
1667 span_style = resolver.resolve(span_style, scope, phase);
1668 }
1669 }
1670
1671 x = crate::draw_text_span_with_link(
1672 frame,
1673 x,
1674 line_y,
1675 &span.content,
1676 span_style,
1677 cell_area.right(),
1678 span.link.as_deref(),
1679 );
1680 if x >= cell_area.right() {
1681 break;
1682 }
1683 }
1684}
1685
1686fn theme_has_column_effects(theme: &TableTheme) -> bool {
1687 theme.effects.iter().any(|rule| {
1688 matches!(
1689 rule.target,
1690 TableEffectTarget::Column(_) | TableEffectTarget::ColumnRange { .. }
1691 )
1692 })
1693}
1694
1695fn divider_char(block: Option<&Block<'_>>) -> char {
1696 block
1697 .map(|b| b.border_set().vertical)
1698 .unwrap_or(crate::borders::BorderSet::SQUARE.vertical)
1699}
1700
1701fn draw_vertical_dividers(
1702 buf: &mut Buffer,
1703 row_area: Rect,
1704 col_rects: &[Rect],
1705 divider_char: char,
1706 style: Style,
1707) {
1708 if col_rects.len() < 2 || row_area.is_empty() {
1709 return;
1710 }
1711
1712 for pair in col_rects.windows(2) {
1713 let left = pair[0];
1714 let right = pair[1];
1715 let gap = right.x.saturating_sub(left.right());
1716 if gap == 0 {
1717 continue;
1718 }
1719 let x = left.right();
1720 if x >= row_area.right() {
1721 continue;
1722 }
1723 let mut cell = Cell::from_char(divider_char);
1724 apply_style(&mut cell, style);
1725 for y in row_area.y..row_area.bottom() {
1726 buf.set_fast(x, y, cell);
1727 }
1728 }
1729}
1730
1731impl MeasurableWidget for Table<'_> {
1732 fn measure(&self, _available: Size) -> SizeConstraints {
1733 if self.rows.is_empty() && self.header.is_none() {
1734 return SizeConstraints::ZERO;
1735 }
1736
1737 let col_count = self.widths.len();
1738 if col_count == 0 {
1739 return SizeConstraints::ZERO;
1740 }
1741
1742 let cell_padding = self.effective_cell_padding();
1743 let pad_extra = cell_padding.saturating_mul(2);
1744 let row_widths = Self::compute_intrinsic_widths(&self.rows, None, col_count, cell_padding);
1745
1746 let separator_width = if col_count > 1 {
1748 ((col_count - 1) as u16).saturating_mul(self.effective_column_spacing())
1749 } else {
1750 0
1751 };
1752
1753 let mut summed_col_width = 0u16;
1754 for (i, &r_w) in row_widths.iter().enumerate() {
1755 let h_w = self
1756 .header
1757 .as_ref()
1758 .and_then(|h| h.cells.get(i))
1759 .map(|c| (c.width().min(u16::MAX as usize) as u16).saturating_add(pad_extra))
1760 .unwrap_or(0);
1761 summed_col_width = summed_col_width.saturating_add(r_w.max(h_w));
1762 }
1763
1764 let content_width = summed_col_width.saturating_add(separator_width);
1765
1766 let header_height = self
1769 .header
1770 .as_ref()
1771 .map(|h| h.height.saturating_add(h.bottom_margin))
1772 .unwrap_or(0);
1773
1774 let rows_height: u16 = self.rows.iter().fold(0u16, |acc, r| {
1775 acc.saturating_add(r.height.saturating_add(r.bottom_margin))
1776 });
1777
1778 let content_height = header_height.saturating_add(rows_height);
1779
1780 let (block_width, block_height) = self
1782 .block
1783 .as_ref()
1784 .map(|b| {
1785 let inner = b.inner(Rect::new(0, 0, 100, 100));
1786 let w_overhead = 100u16.saturating_sub(inner.width);
1787 let h_overhead = 100u16.saturating_sub(inner.height);
1788 (w_overhead, h_overhead)
1789 })
1790 .unwrap_or((0, 0));
1791
1792 let total_width = content_width.saturating_add(block_width);
1793 let total_height = content_height.saturating_add(block_height);
1794
1795 SizeConstraints {
1796 min: Size::new(
1797 (col_count as u16).saturating_add(block_width),
1798 header_height.max(1).saturating_add(block_height),
1799 ),
1800 preferred: Size::new(total_width, total_height),
1801 max: Some(Size::new(total_width, total_height)), }
1803 }
1804
1805 fn has_intrinsic_size(&self) -> bool {
1806 !self.rows.is_empty() || self.header.is_some()
1807 }
1808}
1809
1810#[cfg(test)]
1811mod tests {
1812 use super::*;
1813 use ftui_render::buffer::Buffer;
1814 use ftui_render::cell::PackedRgba;
1815 use ftui_render::grapheme_pool::GraphemePool;
1816 use ftui_text::{Line, Span};
1817 #[cfg(feature = "tracing")]
1818 use std::sync::{Arc, Mutex};
1819 #[cfg(feature = "tracing")]
1820 use tracing::Subscriber;
1821 #[cfg(feature = "tracing")]
1822 use tracing_subscriber::Layer;
1823 #[cfg(feature = "tracing")]
1824 use tracing_subscriber::layer::{Context, SubscriberExt};
1825
1826 fn cell_char(buf: &Buffer, x: u16, y: u16) -> Option<char> {
1827 buf.get(x, y).and_then(|c| c.content.as_char())
1828 }
1829
1830 fn cell_fg(buf: &Buffer, x: u16, y: u16) -> Option<PackedRgba> {
1831 buf.get(x, y).map(|c| c.fg)
1832 }
1833
1834 fn row_text(buf: &Buffer, y: u16) -> String {
1835 let width = buf.width();
1836 let mut actual = String::new();
1837 for x in 0..width {
1838 let ch = buf
1839 .get(x, y)
1840 .and_then(|cell| cell.content.as_char())
1841 .unwrap_or(' ');
1842 actual.push(ch);
1843 }
1844 actual.trim().to_string()
1845 }
1846
1847 fn raw_row_text(buf: &Buffer, y: u16) -> String {
1848 let width = buf.width();
1849 let mut actual = String::new();
1850 for x in 0..width {
1851 let ch = buf
1852 .get(x, y)
1853 .and_then(|cell| cell.content.as_char())
1854 .unwrap_or(' ');
1855 actual.push(ch);
1856 }
1857 actual
1858 }
1859
1860 #[cfg(feature = "tracing")]
1861 #[derive(Debug, Default)]
1862 struct TableTraceState {
1863 span_count: usize,
1864 has_total_rows_field: bool,
1865 has_rendered_rows_field: bool,
1866 total_rows: Vec<u64>,
1867 rendered_rows: Vec<u64>,
1868 }
1869
1870 #[cfg(feature = "tracing")]
1871 struct TableTraceCapture {
1872 state: Arc<Mutex<TableTraceState>>,
1873 }
1874
1875 #[cfg(feature = "tracing")]
1876 #[derive(Default)]
1877 struct TableRenderVisitor {
1878 total_rows: Option<u64>,
1879 rendered_rows: Option<u64>,
1880 }
1881
1882 #[cfg(feature = "tracing")]
1883 impl tracing::field::Visit for TableRenderVisitor {
1884 fn record_u64(&mut self, field: &tracing::field::Field, value: u64) {
1885 match field.name() {
1886 "total_rows" => self.total_rows = Some(value),
1887 "rendered_rows" => self.rendered_rows = Some(value),
1888 _ => {}
1889 }
1890 }
1891
1892 fn record_i64(&mut self, field: &tracing::field::Field, value: i64) {
1893 if let Ok(value) = u64::try_from(value) {
1894 self.record_u64(field, value);
1895 }
1896 }
1897
1898 fn record_debug(&mut self, field: &tracing::field::Field, value: &dyn std::fmt::Debug) {
1899 let value = format!("{value:?}");
1900 if let Ok(parsed) = value.parse::<u64>() {
1901 self.record_u64(field, parsed);
1902 }
1903 }
1904 }
1905
1906 #[cfg(feature = "tracing")]
1907 impl<S> Layer<S> for TableTraceCapture
1908 where
1909 S: Subscriber + for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>,
1910 {
1911 fn on_new_span(
1912 &self,
1913 attrs: &tracing::span::Attributes<'_>,
1914 _id: &tracing::Id,
1915 _ctx: Context<'_, S>,
1916 ) {
1917 if attrs.metadata().name() != "table.render" {
1918 return;
1919 }
1920
1921 let mut visitor = TableRenderVisitor::default();
1922 attrs.record(&mut visitor);
1923 let fields = attrs.metadata().fields();
1924
1925 let mut state = self.state.lock().expect("table trace state lock");
1926 state.span_count += 1;
1927 state.has_total_rows_field |= fields.field("total_rows").is_some();
1928 state.has_rendered_rows_field |= fields.field("rendered_rows").is_some();
1929 if let Some(total_rows) = visitor.total_rows {
1930 state.total_rows.push(total_rows);
1931 }
1932 if let Some(rendered_rows) = visitor.rendered_rows {
1933 state.rendered_rows.push(rendered_rows);
1934 }
1935 }
1936
1937 fn on_record(
1938 &self,
1939 id: &tracing::Id,
1940 values: &tracing::span::Record<'_>,
1941 ctx: Context<'_, S>,
1942 ) {
1943 let Some(span_ref) = ctx.span(id) else {
1944 return;
1945 };
1946 if span_ref.metadata().name() != "table.render" {
1947 return;
1948 }
1949
1950 let mut visitor = TableRenderVisitor::default();
1951 values.record(&mut visitor);
1952
1953 let mut state = self.state.lock().expect("table trace state lock");
1954 if let Some(total_rows) = visitor.total_rows {
1955 state.total_rows.push(total_rows);
1956 }
1957 if let Some(rendered_rows) = visitor.rendered_rows {
1958 state.rendered_rows.push(rendered_rows);
1959 }
1960 }
1961 }
1962
1963 #[test]
1966 fn row_new_from_strings() {
1967 let row = Row::new(["A", "B", "C"]);
1968 assert_eq!(row.cells.len(), 3);
1969 assert_eq!(row.height, 1);
1970 assert_eq!(row.bottom_margin, 0);
1971 }
1972
1973 #[test]
1974 fn row_builder_methods() {
1975 let row = Row::new(["X"])
1976 .height(3)
1977 .bottom_margin(1)
1978 .style(Style::new().bold());
1979 assert_eq!(row.height, 3);
1980 assert_eq!(row.bottom_margin, 1);
1981 assert!(row.style.has_attr(ftui_style::StyleFlags::BOLD));
1982 }
1983
1984 #[test]
1985 fn row_height_zero_clamps_to_one() {
1986 let row = Row::new(["X"]).height(0);
1987 assert_eq!(row.height, 1);
1988 }
1989
1990 #[test]
1993 fn table_state_default() {
1994 let state = TableState::default();
1995 assert_eq!(state.selected, None);
1996 assert_eq!(state.offset, 0);
1997 }
1998
1999 #[test]
2000 fn table_state_select() {
2001 let mut state = TableState::default();
2002 state.select(Some(5));
2003 assert_eq!(state.selected, Some(5));
2004 assert_eq!(state.offset, 0);
2005 }
2006
2007 #[test]
2008 fn table_state_deselect_preserves_offset() {
2009 let mut state = TableState {
2010 offset: 10,
2011 ..Default::default()
2012 };
2013 state.select(Some(3));
2014 assert_eq!(state.selected, Some(3));
2015 state.select(None);
2016 assert_eq!(state.selected, None);
2017 assert_eq!(state.offset, 10);
2018 }
2019
2020 #[test]
2021 fn table_state_scroll_down_is_overflow_safe() {
2022 let mut state = TableState {
2024 offset: usize::MAX - 1,
2025 ..Default::default()
2026 };
2027 state.scroll_down(10, 100);
2028 assert_eq!(state.offset, 99);
2029 }
2030
2031 #[test]
2034 fn render_zero_area() {
2035 let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]);
2036 let area = Rect::new(0, 0, 0, 0);
2037 let mut pool = GraphemePool::new();
2038 let mut frame = Frame::new(1, 1, &mut pool);
2039 Widget::render(&table, area, &mut frame);
2040 }
2042
2043 #[test]
2044 fn render_empty_rows() {
2045 let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2046 let area = Rect::new(0, 0, 10, 5);
2047 let mut pool = GraphemePool::new();
2048 let mut frame = Frame::new(10, 5, &mut pool);
2049 Widget::render(&table, area, &mut frame);
2050 }
2052
2053 #[test]
2054 fn render_empty_rows_clears_stale_viewport() {
2055 let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2056 let area = Rect::new(0, 0, 10, 3);
2057 let mut pool = GraphemePool::new();
2058 let mut frame = Frame::new(10, 3, &mut pool);
2059 frame.buffer.fill(area, Cell::from_char('X'));
2060
2061 Widget::render(&table, area, &mut frame);
2062
2063 assert_eq!(raw_row_text(&frame.buffer, 0), " ");
2064 assert_eq!(raw_row_text(&frame.buffer, 1), " ");
2065 assert_eq!(raw_row_text(&frame.buffer, 2), " ");
2066 }
2067
2068 #[test]
2069 fn render_single_row_single_column() {
2070 let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
2071 let area = Rect::new(0, 0, 10, 3);
2072 let mut pool = GraphemePool::new();
2073 let mut frame = Frame::new(10, 3, &mut pool);
2074 Widget::render(&table, area, &mut frame);
2075
2076 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
2077 assert_eq!(cell_char(&frame.buffer, 1, 0), Some('e'));
2078 assert_eq!(cell_char(&frame.buffer, 4, 0), Some('o'));
2079 }
2080
2081 #[test]
2082 fn render_shorter_cell_clears_stale_suffix() {
2083 let area = Rect::new(0, 0, 10, 1);
2084 let mut pool = GraphemePool::new();
2085 let mut frame = Frame::new(10, 1, &mut pool);
2086
2087 let long = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
2088 Widget::render(&long, area, &mut frame);
2089
2090 let short = Table::new([Row::new(["Hi"])], [Constraint::Fixed(10)]);
2091 Widget::render(&short, area, &mut frame);
2092
2093 assert_eq!(raw_row_text(&frame.buffer, 0), "Hi ");
2094 }
2095
2096 #[test]
2097 fn render_multiple_rows() {
2098 let table = Table::new(
2099 [Row::new(["AA", "BB"]), Row::new(["CC", "DD"])],
2100 [Constraint::Fixed(4), Constraint::Fixed(4)],
2101 );
2102 let area = Rect::new(0, 0, 10, 3);
2103 let mut pool = GraphemePool::new();
2104 let mut frame = Frame::new(10, 3, &mut pool);
2105 Widget::render(&table, area, &mut frame);
2106
2107 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2109 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('C'));
2111 }
2112
2113 #[test]
2114 fn render_with_header() {
2115 let header = Row::new(["Name", "Val"]);
2116 let table = Table::new(
2117 [Row::new(["foo", "42"])],
2118 [Constraint::Fixed(5), Constraint::Fixed(4)],
2119 )
2120 .header(header);
2121
2122 let area = Rect::new(0, 0, 10, 3);
2123 let mut pool = GraphemePool::new();
2124 let mut frame = Frame::new(10, 3, &mut pool);
2125 Widget::render(&table, area, &mut frame);
2126
2127 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('N'));
2129 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('f'));
2131 }
2132
2133 #[test]
2134 fn render_shorter_header_clears_stale_suffix() {
2135 let area = Rect::new(0, 0, 10, 2);
2136 let mut pool = GraphemePool::new();
2137 let mut frame = Frame::new(10, 2, &mut pool);
2138
2139 let long =
2140 Table::new([Row::new(["row"])], [Constraint::Fixed(10)]).header(Row::new(["Header"]));
2141 Widget::render(&long, area, &mut frame);
2142
2143 let short =
2144 Table::new([Row::new(["row"])], [Constraint::Fixed(10)]).header(Row::new(["H"]));
2145 Widget::render(&short, area, &mut frame);
2146
2147 assert_eq!(raw_row_text(&frame.buffer, 0), "H ");
2148 }
2149
2150 #[test]
2151 fn zero_height_row_clamps_and_preserves_vertical_flow() {
2152 let table = Table::new(
2153 [Row::new(["A"]).height(0), Row::new(["B"])],
2154 [Constraint::Fixed(3)],
2155 );
2156 let area = Rect::new(0, 0, 3, 2);
2157 let mut pool = GraphemePool::new();
2158 let mut frame = Frame::new(3, 2, &mut pool);
2159 Widget::render(&table, area, &mut frame);
2160
2161 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2162 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
2163 }
2164
2165 #[test]
2166 fn zero_height_header_clamps_to_one_and_offsets_rows() {
2167 let header = Row::new(["H"]).height(0);
2168 let table = Table::new([Row::new(["D"])], [Constraint::Fixed(3)]).header(header);
2169
2170 let area = Rect::new(0, 0, 3, 2);
2171 let mut pool = GraphemePool::new();
2172 let mut frame = Frame::new(3, 2, &mut pool);
2173 Widget::render(&table, area, &mut frame);
2174
2175 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
2176 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('D'));
2177 }
2178
2179 #[test]
2180 fn render_with_block() {
2181 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]).block(Block::bordered());
2182
2183 let area = Rect::new(0, 0, 10, 5);
2184 let mut pool = GraphemePool::new();
2185 let mut frame = Frame::new(10, 5, &mut pool);
2186 Widget::render(&table, area, &mut frame);
2187
2188 assert_eq!(cell_char(&frame.buffer, 2, 2), Some('X'));
2190 }
2191
2192 #[test]
2193 fn stateful_render_with_selection() {
2194 let table = Table::new(
2195 [Row::new(["A"]), Row::new(["B"]), Row::new(["C"])],
2196 [Constraint::Fixed(5)],
2197 )
2198 .highlight_style(Style::new().bold());
2199
2200 let area = Rect::new(0, 0, 5, 3);
2201 let mut pool = GraphemePool::new();
2202 let mut frame = Frame::new(5, 3, &mut pool);
2203 let mut state = TableState::default();
2204 state.select(Some(1));
2205
2206 StatefulWidget::render(&table, area, &mut frame, &mut state);
2207 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
2210 }
2211
2212 #[test]
2213 fn row_style_merge_precedence_and_span_override() {
2214 let base_fg = PackedRgba::rgb(10, 0, 0);
2215 let selected_fg = PackedRgba::rgb(20, 0, 0);
2216 let hovered_fg = PackedRgba::rgb(30, 0, 0);
2217 let table_fg = PackedRgba::rgb(40, 0, 0);
2218 let row_fg = PackedRgba::rgb(50, 0, 0);
2219 let highlight_fg = PackedRgba::rgb(60, 0, 0);
2220 let span_fg = PackedRgba::rgb(70, 0, 0);
2221
2222 let base_row = Style::new().fg(base_fg);
2223 let theme = TableTheme {
2224 row: base_row,
2225 row_alt: base_row,
2226 row_selected: Style::new().fg(selected_fg),
2227 row_hover: Style::new().fg(hovered_fg),
2228 ..Default::default()
2229 };
2230
2231 let text = Text::from_line(Line::from_spans([
2232 Span::raw("A"),
2233 Span::styled("B", Style::new().fg(span_fg)),
2234 ]));
2235
2236 let table = Table::new(
2237 [Row::new([text]).style(Style::new().fg(row_fg))],
2238 [Constraint::Fixed(2)],
2239 )
2240 .style(Style::new().fg(table_fg))
2241 .highlight_style(Style::new().fg(highlight_fg))
2242 .theme(theme);
2243
2244 let area = Rect::new(0, 0, 2, 1);
2245 let mut pool = GraphemePool::new();
2246 let mut frame = Frame::new(2, 1, &mut pool);
2247 let mut state = TableState {
2248 selected: Some(0),
2249 hovered: Some(0),
2250 ..Default::default()
2251 };
2252
2253 StatefulWidget::render(&table, area, &mut frame, &mut state);
2254
2255 assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(highlight_fg));
2256 assert_eq!(cell_fg(&frame.buffer, 1, 0), Some(span_fg));
2257 }
2258
2259 #[test]
2260 fn selection_below_offset_adjusts_offset() {
2261 let mut state = TableState {
2262 offset: 5,
2263 selected: Some(2), persistence_id: None,
2265 ..Default::default()
2266 };
2267
2268 let table = Table::new(
2269 (0..10).map(|i| Row::new([format!("Row {i}")])),
2270 [Constraint::Fixed(10)],
2271 );
2272 let area = Rect::new(0, 0, 10, 3);
2273 let mut pool = GraphemePool::new();
2274 let mut frame = Frame::new(10, 3, &mut pool);
2275 StatefulWidget::render(&table, area, &mut frame, &mut state);
2276
2277 assert_eq!(state.offset, 2);
2279 }
2280
2281 #[test]
2282 fn table_clamps_offset_to_fill_viewport_on_resize() {
2283 let rows: Vec<Row> = (0..10).map(|i| Row::new([format!("Row {i}")])).collect();
2284 let table = Table::new(rows, [Constraint::Min(10)]);
2285
2286 let mut pool = GraphemePool::new();
2287 let mut state = TableState {
2288 offset: 7,
2289 ..Default::default()
2290 };
2291
2292 let area_small = Rect::new(0, 0, 10, 3);
2294 let mut frame_small = Frame::new(10, 3, &mut pool);
2295 StatefulWidget::render(&table, area_small, &mut frame_small, &mut state);
2296 assert_eq!(state.offset, 7);
2297 assert_eq!(row_text(&frame_small.buffer, 0), "Row 7");
2298 assert_eq!(row_text(&frame_small.buffer, 2), "Row 9");
2299
2300 let area_large = Rect::new(0, 0, 10, 5);
2302 let mut frame_large = Frame::new(10, 5, &mut pool);
2303 StatefulWidget::render(&table, area_large, &mut frame_large, &mut state);
2304 assert_eq!(state.offset, 5);
2305 assert_eq!(row_text(&frame_large.buffer, 0), "Row 5");
2306 assert_eq!(row_text(&frame_large.buffer, 4), "Row 9");
2307 }
2308
2309 #[test]
2310 fn table_clamps_offset_to_fill_viewport_with_variable_row_heights() {
2311 let mut rows: Vec<Row> = (0..9).map(|i| Row::new([format!("Row {i}")])).collect();
2315 rows.push(Row::new(["Row 9"]).height(5));
2316 let table = Table::new(rows, [Constraint::Min(10)]);
2317
2318 let mut pool = GraphemePool::new();
2319 let mut state = TableState {
2320 offset: 9,
2321 ..Default::default()
2322 };
2323
2324 let area = Rect::new(0, 0, 10, 10);
2325 let mut frame = Frame::new(10, 10, &mut pool);
2326 StatefulWidget::render(&table, area, &mut frame, &mut state);
2327
2328 assert_eq!(state.offset, 4);
2329 assert_eq!(row_text(&frame.buffer, 0), "Row 4");
2330 }
2331
2332 #[test]
2333 fn selection_invalid_index_falls_back_to_first_row() {
2334 let table = Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(5)]);
2335 let area = Rect::new(0, 0, 5, 2);
2336 let mut pool = GraphemePool::new();
2337 let mut frame = Frame::new(5, 2, &mut pool);
2338 let mut state = TableState {
2339 offset: 0,
2340 selected: Some(99),
2341 persistence_id: None,
2342 ..Default::default()
2343 };
2344
2345 StatefulWidget::render(&table, area, &mut frame, &mut state);
2346 assert_eq!(state.selected, Some(0));
2347 }
2348
2349 #[test]
2350 fn selection_with_header_accounts_for_header_height() {
2351 let header = Row::new(["H"]);
2352 let table =
2353 Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(5)]).header(header);
2354
2355 let area = Rect::new(0, 0, 5, 2);
2356 let mut pool = GraphemePool::new();
2357 let mut frame = Frame::new(5, 2, &mut pool);
2358 let mut state = TableState {
2359 offset: 0,
2360 selected: Some(1),
2361 persistence_id: None,
2362 ..Default::default()
2363 };
2364
2365 StatefulWidget::render(&table, area, &mut frame, &mut state);
2366 assert_eq!(state.offset, 1);
2367 }
2368
2369 #[test]
2370 fn rows_overflow_area_truncated() {
2371 let table = Table::new(
2372 (0..20).map(|i| Row::new([format!("R{i}")])),
2373 [Constraint::Fixed(5)],
2374 );
2375 let area = Rect::new(0, 0, 5, 3);
2376 let mut pool = GraphemePool::new();
2377 let mut frame = Frame::new(5, 3, &mut pool);
2378 Widget::render(&table, area, &mut frame);
2379
2380 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('R'));
2382 assert_eq!(cell_char(&frame.buffer, 1, 0), Some('0'));
2383 assert_eq!(cell_char(&frame.buffer, 1, 2), Some('2'));
2384 }
2385
2386 #[test]
2387 fn column_spacing_applied() {
2388 let table = Table::new(
2389 [Row::new(["A", "B"])],
2390 [Constraint::Fixed(3), Constraint::Fixed(3)],
2391 )
2392 .column_spacing(2);
2393
2394 let area = Rect::new(0, 0, 10, 1);
2395 let mut pool = GraphemePool::new();
2396 let mut frame = Frame::new(10, 1, &mut pool);
2397 Widget::render(&table, area, &mut frame);
2398
2399 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2401 }
2402
2403 #[test]
2404 fn divider_style_overrides_row_style() {
2405 let row_fg = PackedRgba::rgb(120, 10, 10);
2406 let divider_fg = PackedRgba::rgb(0, 200, 0);
2407 let row_style = Style::new().fg(row_fg);
2408 let theme = TableTheme {
2409 row: row_style,
2410 row_alt: row_style,
2411 divider: Style::new().fg(divider_fg),
2412 ..Default::default()
2413 };
2414
2415 let table = Table::new(
2416 [Row::new(["AA", "BB"])],
2417 [Constraint::Fixed(2), Constraint::Fixed(2)],
2418 )
2419 .theme(theme);
2420
2421 let area = Rect::new(0, 0, 5, 1);
2422 let mut pool = GraphemePool::new();
2423 let mut frame = Frame::new(5, 1, &mut pool);
2424 Widget::render(&table, area, &mut frame);
2425
2426 assert_eq!(cell_fg(&frame.buffer, 2, 0), Some(divider_fg));
2427 }
2428
2429 #[test]
2430 fn block_border_uses_theme_border_style() {
2431 let border_fg = PackedRgba::rgb(1, 2, 3);
2432 let theme = TableTheme {
2433 border: Style::new().fg(border_fg),
2434 ..Default::default()
2435 };
2436
2437 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(1)])
2438 .block(Block::bordered())
2439 .theme(theme);
2440
2441 let area = Rect::new(0, 0, 3, 3);
2442 let mut pool = GraphemePool::new();
2443 let mut frame = Frame::new(3, 3, &mut pool);
2444 Widget::render(&table, area, &mut frame);
2445
2446 assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(border_fg));
2447 }
2448
2449 #[test]
2450 fn render_clips_long_cell_to_column_width() {
2451 let table = Table::new([Row::new(["ABCDE"])], [Constraint::Fixed(3)]);
2452 let area = Rect::new(0, 0, 3, 1);
2453 let mut pool = GraphemePool::new();
2454 let mut frame = Frame::new(4, 1, &mut pool);
2455 Widget::render(&table, area, &mut frame);
2456
2457 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2458 assert_eq!(cell_char(&frame.buffer, 1, 0), Some('B'));
2459 assert_eq!(cell_char(&frame.buffer, 2, 0), Some('C'));
2460 assert_ne!(cell_char(&frame.buffer, 3, 0), Some('D'));
2461 }
2462
2463 #[test]
2464 fn render_multiline_cell_respects_row_height() {
2465 let table = Table::new([Row::new(["A\nB"]).height(1)], [Constraint::Fixed(3)]);
2466 let area = Rect::new(0, 0, 3, 2);
2467 let mut pool = GraphemePool::new();
2468 let mut frame = Frame::new(3, 2, &mut pool);
2469 Widget::render(&table, area, &mut frame);
2470
2471 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2472 assert_ne!(cell_char(&frame.buffer, 0, 1), Some('B'));
2473 }
2474
2475 #[test]
2476 fn render_multiline_cell_draws_second_line_when_height_allows() {
2477 let table = Table::new([Row::new(["A\nB"]).height(2)], [Constraint::Fixed(3)]);
2478 let area = Rect::new(0, 0, 3, 2);
2479 let mut pool = GraphemePool::new();
2480 let mut frame = Frame::new(3, 2, &mut pool);
2481 Widget::render(&table, area, &mut frame);
2482
2483 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2484 assert_eq!(cell_char(&frame.buffer, 0, 1), Some('B'));
2485 }
2486
2487 #[test]
2488 fn more_cells_than_columns_truncated() {
2489 let table = Table::new(
2490 [Row::new(["A", "B", "C", "D"])],
2491 [Constraint::Fixed(3), Constraint::Fixed(3)],
2492 );
2493 let area = Rect::new(0, 0, 8, 1);
2494 let mut pool = GraphemePool::new();
2495 let mut frame = Frame::new(8, 1, &mut pool);
2496 Widget::render(&table, area, &mut frame);
2497 }
2499
2500 #[test]
2501 fn header_too_tall_for_area() {
2502 let header = Row::new(["H"]).height(10);
2503 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]).header(header);
2504
2505 let area = Rect::new(0, 0, 5, 3);
2506 let mut pool = GraphemePool::new();
2507 let mut frame = Frame::new(5, 3, &mut pool);
2508 Widget::render(&table, area, &mut frame);
2509 }
2511
2512 #[test]
2513 fn row_with_bottom_margin() {
2514 let table = Table::new(
2515 [Row::new(["A"]).bottom_margin(1), Row::new(["B"])],
2516 [Constraint::Fixed(5)],
2517 );
2518 let area = Rect::new(0, 0, 5, 4);
2519 let mut pool = GraphemePool::new();
2520 let mut frame = Frame::new(5, 4, &mut pool);
2521 Widget::render(&table, area, &mut frame);
2522
2523 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
2525 assert_eq!(cell_char(&frame.buffer, 0, 2), Some('B'));
2526 }
2527
2528 #[test]
2529 fn table_registers_hit_regions() {
2530 let table = Table::new(
2531 [Row::new(["A"]), Row::new(["B"]), Row::new(["C"])],
2532 [Constraint::Fixed(5)],
2533 )
2534 .hit_id(HitId::new(99));
2535
2536 let area = Rect::new(0, 0, 5, 3);
2537 let mut pool = GraphemePool::new();
2538 let mut frame = Frame::with_hit_grid(5, 3, &mut pool);
2539 let mut state = TableState::default();
2540 StatefulWidget::render(&table, area, &mut frame, &mut state);
2541
2542 let hit0 = frame.hit_test(2, 0);
2544 let hit1 = frame.hit_test(2, 1);
2545 let hit2 = frame.hit_test(2, 2);
2546
2547 assert_eq!(hit0, Some((HitId::new(99), HitRegion::Content, 0)));
2548 assert_eq!(hit1, Some((HitId::new(99), HitRegion::Content, 1)));
2549 assert_eq!(hit2, Some((HitId::new(99), HitRegion::Content, 2)));
2550 }
2551
2552 #[test]
2553 fn table_no_hit_without_hit_id() {
2554 let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]);
2555 let area = Rect::new(0, 0, 5, 1);
2556 let mut pool = GraphemePool::new();
2557 let mut frame = Frame::with_hit_grid(5, 1, &mut pool);
2558 let mut state = TableState::default();
2559 StatefulWidget::render(&table, area, &mut frame, &mut state);
2560
2561 assert!(frame.hit_test(2, 0).is_none());
2563 }
2564
2565 #[test]
2566 fn table_no_hit_without_hit_grid() {
2567 let table = Table::new([Row::new(["A"])], [Constraint::Fixed(5)]).hit_id(HitId::new(1));
2568 let area = Rect::new(0, 0, 5, 1);
2569 let mut pool = GraphemePool::new();
2570 let mut frame = Frame::new(5, 1, &mut pool); let mut state = TableState::default();
2572 StatefulWidget::render(&table, area, &mut frame, &mut state);
2573
2574 assert!(frame.hit_test(2, 0).is_none());
2576 }
2577
2578 #[test]
2581 fn measure_empty_table() {
2582 let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2583 let c = table.measure(Size::MAX);
2584 assert_eq!(c, SizeConstraints::ZERO);
2585 }
2586
2587 #[test]
2588 fn measure_empty_columns() {
2589 let table = Table::new([Row::new(["A"])], Vec::<Constraint>::new());
2590 let c = table.measure(Size::MAX);
2591 assert_eq!(c, SizeConstraints::ZERO);
2592 }
2593
2594 #[test]
2595 fn measure_single_row() {
2596 let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(10)]);
2597 let c = table.measure(Size::MAX);
2598
2599 assert_eq!(c.preferred.width, 5); assert_eq!(c.preferred.height, 1); assert!(table.has_intrinsic_size());
2602 }
2603
2604 #[test]
2605 fn measure_multiple_columns() {
2606 let table = Table::new(
2607 [Row::new(["A", "BB", "CCC"])],
2608 [
2609 Constraint::Fixed(5),
2610 Constraint::Fixed(5),
2611 Constraint::Fixed(5),
2612 ],
2613 )
2614 .column_spacing(2);
2615
2616 let c = table.measure(Size::MAX);
2617
2618 assert_eq!(c.preferred.width, 10);
2620 assert_eq!(c.preferred.height, 1);
2621 }
2622
2623 #[test]
2624 fn measure_respects_row_height_and_column_spacing() {
2625 let table = Table::new(
2626 [Row::new(["A", "BB"]).height(2)],
2627 [Constraint::FitContent, Constraint::FitContent],
2628 )
2629 .column_spacing(2);
2630
2631 let c = table.measure(Size::MAX);
2632
2633 assert_eq!(c.preferred.width, 5);
2634 assert_eq!(c.preferred.height, 2);
2635 }
2636
2637 #[test]
2638 fn measure_accounts_for_wide_glyphs() {
2639 let table = Table::new(
2640 [Row::new(["界", "A"])],
2641 [Constraint::FitContent, Constraint::FitContent],
2642 )
2643 .column_spacing(1);
2644
2645 let c = table.measure(Size::MAX);
2646
2647 assert_eq!(c.preferred.width, 4);
2648 assert_eq!(c.preferred.height, 1);
2649 }
2650
2651 #[test]
2652 fn measure_with_header() {
2653 let header = Row::new(["Name", "Value"]);
2654 let table = Table::new(
2655 [Row::new(["foo", "42"])],
2656 [Constraint::Fixed(5), Constraint::Fixed(5)],
2657 )
2658 .header(header);
2659
2660 let c = table.measure(Size::MAX);
2661
2662 assert_eq!(c.preferred.width, 10);
2665 assert_eq!(c.preferred.height, 2);
2667 }
2668
2669 #[test]
2670 fn measure_with_row_margins() {
2671 let table = Table::new(
2672 [
2673 Row::new(["A"]).bottom_margin(2),
2674 Row::new(["B"]).bottom_margin(1),
2675 ],
2676 [Constraint::Fixed(5)],
2677 );
2678
2679 let c = table.measure(Size::MAX);
2680
2681 assert_eq!(c.preferred.height, 5);
2683 }
2684
2685 #[test]
2686 fn measure_column_widths_from_max_cell() {
2687 let table = Table::new(
2688 [Row::new(["A", "BB"]), Row::new(["CCC", "D"])],
2689 [Constraint::Fixed(5), Constraint::Fixed(5)],
2690 )
2691 .column_spacing(1);
2692
2693 let c = table.measure(Size::MAX);
2694
2695 assert_eq!(c.preferred.width, 6);
2699 assert_eq!(c.preferred.height, 2);
2700 }
2701
2702 #[test]
2703 fn measure_min_is_column_count() {
2704 let table = Table::new(
2705 [Row::new(["A", "B", "C"])],
2706 [
2707 Constraint::Fixed(5),
2708 Constraint::Fixed(5),
2709 Constraint::Fixed(5),
2710 ],
2711 );
2712
2713 let c = table.measure(Size::MAX);
2714
2715 assert_eq!(c.min.width, 3);
2717 assert_eq!(c.min.height, 1);
2718 }
2719
2720 #[test]
2721 fn measure_has_intrinsic_size() {
2722 let empty = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
2723 assert!(!empty.has_intrinsic_size());
2724
2725 let with_rows = Table::new([Row::new(["X"])], [Constraint::Fixed(5)]);
2726 assert!(with_rows.has_intrinsic_size());
2727
2728 let header_only =
2729 Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]).header(Row::new(["Header"]));
2730 assert!(header_only.has_intrinsic_size());
2731 }
2732
2733 use crate::stateful::Stateful;
2736
2737 #[test]
2738 fn table_state_with_persistence_id() {
2739 let state = TableState::default().with_persistence_id("my-table");
2740 assert_eq!(state.persistence_id(), Some("my-table"));
2741 }
2742
2743 #[test]
2744 fn table_state_default_no_persistence_id() {
2745 let state = TableState::default();
2746 assert_eq!(state.persistence_id(), None);
2747 }
2748
2749 #[test]
2750 fn table_state_save_restore_round_trip() {
2751 let mut state = TableState::default().with_persistence_id("test");
2752 state.select(Some(5));
2753 state.offset = 3;
2754 state.set_sort(Some(2), true);
2755 state.set_filter("search term");
2756
2757 let saved = state.save_state();
2758 assert_eq!(saved.selected, Some(5));
2759 assert_eq!(saved.offset, 3);
2760 assert_eq!(saved.sort_column, Some(2));
2761 assert!(saved.sort_ascending);
2762 assert_eq!(saved.filter, "search term");
2763
2764 state.select(None);
2766 state.offset = 0;
2767 state.set_sort(None, false);
2768 state.set_filter("");
2769 assert_eq!(state.selected, None);
2770 assert_eq!(state.offset, 0);
2771 assert_eq!(state.sort_column(), None);
2772 assert!(!state.sort_ascending());
2773 assert!(state.filter().is_empty());
2774
2775 state.restore_state(saved);
2777 assert_eq!(state.selected, Some(5));
2778 assert_eq!(state.offset, 3);
2779 assert_eq!(state.sort_column(), Some(2));
2780 assert!(state.sort_ascending());
2781 assert_eq!(state.filter(), "search term");
2782 }
2783
2784 #[test]
2785 fn table_state_key_uses_persistence_id() {
2786 let state = TableState::default().with_persistence_id("main-data-table");
2787 let key = state.state_key().expect("named table has a key");
2788 assert_eq!(key.widget_type, "Table");
2789 assert_eq!(key.instance_id, "main-data-table");
2790 }
2791
2792 #[test]
2793 fn table_state_without_id_is_not_persisted() {
2794 assert!(TableState::default().state_key().is_none());
2795 }
2796
2797 #[test]
2798 fn table_persist_state_default() {
2799 let persist = TablePersistState::default();
2800 assert_eq!(persist.selected, None);
2801 assert_eq!(persist.offset, 0);
2802 assert_eq!(persist.sort_column, None);
2803 assert!(!persist.sort_ascending);
2804 assert!(persist.filter.is_empty());
2805 }
2806
2807 #[test]
2812 fn table_state_undo_widget_id_unique() {
2813 let state1 = TableState::default();
2814 let state2 = TableState::default();
2815 assert_ne!(state1.undo_id(), state2.undo_id());
2816 }
2817
2818 #[test]
2819 fn table_state_undo_snapshot_and_restore() {
2820 let mut state = TableState::default();
2821 state.select(Some(5));
2822 state.offset = 2;
2823 state.set_sort(Some(1), false);
2824 state.set_filter("test filter");
2825
2826 let snapshot = state.create_snapshot();
2828
2829 state.select(Some(10));
2831 state.offset = 7;
2832 state.set_sort(Some(3), true);
2833 state.set_filter("new filter");
2834
2835 assert_eq!(state.selected, Some(10));
2836 assert_eq!(state.offset, 7);
2837 assert_eq!(state.sort_column(), Some(3));
2838 assert!(state.sort_ascending());
2839 assert_eq!(state.filter(), "new filter");
2840
2841 assert!(state.restore_snapshot(&*snapshot));
2843
2844 assert_eq!(state.selected, Some(5));
2846 assert_eq!(state.offset, 2);
2847 assert_eq!(state.sort_column(), Some(1));
2848 assert!(!state.sort_ascending());
2849 assert_eq!(state.filter(), "test filter");
2850 }
2851
2852 #[test]
2853 fn table_state_undo_ext_sort() {
2854 let mut state = TableState::default();
2855
2856 assert_eq!(state.sort_state(), (None, false));
2858
2859 state.set_sort_state(Some(2), true);
2861 assert_eq!(state.sort_state(), (Some(2), true));
2862
2863 state.set_sort_state(Some(0), false);
2865 assert_eq!(state.sort_state(), (Some(0), false));
2866 }
2867
2868 #[test]
2869 fn table_state_undo_ext_filter() {
2870 let mut state = TableState::default();
2871
2872 assert_eq!(state.filter_text(), "");
2874
2875 state.set_filter_text("search term");
2877 assert_eq!(state.filter_text(), "search term");
2878
2879 state.set_filter_text("");
2881 assert_eq!(state.filter_text(), "");
2882 }
2883
2884 #[test]
2885 fn table_state_restore_wrong_snapshot_type_fails() {
2886 use std::any::Any;
2887 let mut state = TableState::default();
2888 let wrong_snapshot: Box<dyn Any + Send> = Box::new(42i32);
2889 assert!(!state.restore_snapshot(&*wrong_snapshot));
2890 }
2891
2892 use crate::mouse::MouseResult;
2895 use ftui_core::event::{MouseButton, MouseEvent, MouseEventKind};
2896
2897 #[test]
2898 fn table_state_click_selects() {
2899 let mut state = TableState::default();
2900 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2901 let hit = Some((HitId::new(1), HitRegion::Content, 4u64));
2902 let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2903 assert_eq!(result, MouseResult::Selected(4));
2904 assert_eq!(state.selected, Some(4));
2905 }
2906
2907 #[test]
2908 fn table_state_second_click_activates() {
2909 let mut state = TableState::default();
2910 state.select(Some(4));
2911
2912 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2913 let hit = Some((HitId::new(1), HitRegion::Content, 4u64));
2914 let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2915 assert_eq!(result, MouseResult::Activated(4));
2916 assert_eq!(state.selected, Some(4));
2917 }
2918
2919 #[test]
2920 fn table_state_click_wrong_id_ignored() {
2921 let mut state = TableState::default();
2922 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 2);
2923 let hit = Some((HitId::new(99), HitRegion::Content, 4u64));
2924 let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2925 assert_eq!(result, MouseResult::Ignored);
2926 }
2927
2928 #[test]
2929 fn table_state_hover_updates() {
2930 let mut state = TableState::default();
2931 let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2932 let hit = Some((HitId::new(1), HitRegion::Content, 3u64));
2933 let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2934 assert_eq!(result, MouseResult::HoverChanged);
2935 assert_eq!(state.hovered, Some(3));
2936 }
2937
2938 #[test]
2939 #[allow(clippy::field_reassign_with_default)]
2940 fn table_state_hover_same_index_ignored() {
2941 let mut state = {
2942 let mut s = TableState::default();
2943 s.hovered = Some(3);
2944 s
2945 };
2946 let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2947 let hit = Some((HitId::new(1), HitRegion::Content, 3u64));
2948 let result = state.handle_mouse(&event, hit, HitId::new(1), 10);
2949 assert_eq!(result, MouseResult::Ignored);
2950 assert_eq!(state.hovered, Some(3));
2951 }
2952
2953 #[test]
2954 #[allow(clippy::field_reassign_with_default)]
2955 fn table_state_hover_clears() {
2956 let mut state = {
2957 let mut s = TableState::default();
2958 s.hovered = Some(5);
2959 s
2960 };
2961 let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2962 let result = state.handle_mouse(&event, None, HitId::new(1), 10);
2964 assert_eq!(result, MouseResult::HoverChanged);
2965 assert_eq!(state.hovered, None);
2966 }
2967
2968 #[test]
2969 fn table_state_hover_clear_when_already_none() {
2970 let mut state = TableState::default();
2971 let event = MouseEvent::new(MouseEventKind::Moved, 5, 2);
2972 let result = state.handle_mouse(&event, None, HitId::new(1), 10);
2973 assert_eq!(result, MouseResult::Ignored);
2974 }
2975
2976 #[test]
2977 #[allow(clippy::field_reassign_with_default)]
2978 fn table_state_scroll_wheel_up() {
2979 let mut state = {
2980 let mut s = TableState::default();
2981 s.offset = 10;
2982 s
2983 };
2984 let event = MouseEvent::new(MouseEventKind::ScrollUp, 0, 0);
2985 let result = state.handle_mouse(&event, None, HitId::new(1), 20);
2986 assert_eq!(result, MouseResult::Scrolled);
2987 assert_eq!(state.offset, 7);
2988 }
2989
2990 #[test]
2991 fn table_state_scroll_wheel_down() {
2992 let mut state = TableState::default();
2993 let event = MouseEvent::new(MouseEventKind::ScrollDown, 0, 0);
2994 let result = state.handle_mouse(&event, None, HitId::new(1), 20);
2995 assert_eq!(result, MouseResult::Scrolled);
2996 assert_eq!(state.offset, 3);
2997 }
2998
2999 #[test]
3000 #[allow(clippy::field_reassign_with_default)]
3001 fn table_state_scroll_down_clamps() {
3002 let mut state = {
3003 let mut s = TableState::default();
3004 s.offset = 18;
3005 s
3006 };
3007 state.scroll_down(5, 20);
3008 assert_eq!(state.offset, 19);
3009 }
3010
3011 #[test]
3012 #[allow(clippy::field_reassign_with_default)]
3013 fn table_state_scroll_up_clamps() {
3014 let mut state = {
3015 let mut s = TableState::default();
3016 s.offset = 1;
3017 s
3018 };
3019 state.scroll_up(5);
3020 assert_eq!(state.offset, 0);
3021 }
3022
3023 #[test]
3028 fn row_with_fewer_cells_than_columns() {
3029 let table = Table::new(
3031 [Row::new(["A"])],
3032 [
3033 Constraint::Fixed(3),
3034 Constraint::Fixed(3),
3035 Constraint::Fixed(3),
3036 ],
3037 );
3038 let area = Rect::new(0, 0, 12, 1);
3039 let mut pool = GraphemePool::new();
3040 let mut frame = Frame::new(12, 1, &mut pool);
3041 Widget::render(&table, area, &mut frame);
3042
3043 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
3044 assert_ne!(cell_char(&frame.buffer, 4, 0), Some('A'));
3046 }
3047
3048 #[test]
3049 fn column_spacing_zero() {
3050 let table = Table::new(
3052 [Row::new(["AB", "CD"])],
3053 [Constraint::Fixed(2), Constraint::Fixed(2)],
3054 )
3055 .column_spacing(0);
3056
3057 let area = Rect::new(0, 0, 4, 1);
3058 let mut pool = GraphemePool::new();
3059 let mut frame = Frame::new(4, 1, &mut pool);
3060 Widget::render(&table, area, &mut frame);
3061
3062 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
3063 assert_eq!(cell_char(&frame.buffer, 1, 0), Some('B'));
3064 assert_eq!(cell_char(&frame.buffer, 2, 0), Some('C'));
3065 assert_eq!(cell_char(&frame.buffer, 3, 0), Some('D'));
3066 }
3067
3068 #[test]
3069 fn render_with_nonzero_origin() {
3070 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)]);
3072 let area = Rect::new(5, 3, 3, 1);
3073 let mut pool = GraphemePool::new();
3074 let mut frame = Frame::new(10, 6, &mut pool);
3075 Widget::render(&table, area, &mut frame);
3076
3077 assert_eq!(cell_char(&frame.buffer, 5, 3), Some('X'));
3078 assert_ne!(cell_char(&frame.buffer, 0, 0), Some('X'));
3080 }
3081
3082 #[test]
3083 fn single_row_height_exceeds_area() {
3084 let table = Table::new([Row::new(["T"]).height(10)], [Constraint::Fixed(3)]);
3086 let area = Rect::new(0, 0, 3, 2);
3087 let mut pool = GraphemePool::new();
3088 let mut frame = Frame::new(3, 2, &mut pool);
3089 Widget::render(&table, area, &mut frame);
3090
3091 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('T'));
3093 }
3094
3095 #[test]
3096 fn selection_and_hover_on_same_row() {
3097 let selected_fg = PackedRgba::rgb(100, 0, 0);
3099 let hovered_fg = PackedRgba::rgb(0, 100, 0);
3100 let highlight_fg = PackedRgba::rgb(0, 0, 100);
3101
3102 let theme = TableTheme {
3103 row_selected: Style::new().fg(selected_fg),
3104 row_hover: Style::new().fg(hovered_fg),
3105 ..Default::default()
3106 };
3107
3108 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)])
3109 .highlight_style(Style::new().fg(highlight_fg))
3110 .theme(theme);
3111
3112 let area = Rect::new(0, 0, 3, 1);
3113 let mut pool = GraphemePool::new();
3114 let mut frame = Frame::new(3, 1, &mut pool);
3115 let mut state = TableState {
3116 selected: Some(0),
3117 hovered: Some(0),
3118 ..Default::default()
3119 };
3120
3121 StatefulWidget::render(&table, area, &mut frame, &mut state);
3122 assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(highlight_fg));
3124 }
3125
3126 #[test]
3127 fn alternating_row_styles() {
3128 let even_fg = PackedRgba::rgb(10, 10, 10);
3130 let odd_fg = PackedRgba::rgb(20, 20, 20);
3131 let theme = TableTheme {
3132 row: Style::new().fg(even_fg),
3133 row_alt: Style::new().fg(odd_fg),
3134 ..Default::default()
3135 };
3136
3137 let table = Table::new(
3138 [Row::new(["E"]), Row::new(["O"]), Row::new(["E2"])],
3139 [Constraint::Fixed(3)],
3140 )
3141 .theme(theme);
3142
3143 let area = Rect::new(0, 0, 3, 3);
3144 let mut pool = GraphemePool::new();
3145 let mut frame = Frame::new(3, 3, &mut pool);
3146 Widget::render(&table, area, &mut frame);
3147
3148 assert_eq!(cell_fg(&frame.buffer, 0, 0), Some(even_fg));
3150 assert_eq!(cell_fg(&frame.buffer, 0, 1), Some(odd_fg));
3151 assert_eq!(cell_fg(&frame.buffer, 0, 2), Some(even_fg));
3152 }
3153
3154 #[test]
3155 fn scroll_up_from_zero_stays_zero() {
3156 let mut state = TableState::default();
3157 state.scroll_up(10);
3158 assert_eq!(state.offset, 0);
3159 }
3160
3161 #[test]
3162 fn scroll_down_with_zero_rows() {
3163 let mut state = TableState::default();
3164 state.scroll_down(5, 0);
3165 assert_eq!(state.offset, 0);
3166 }
3167
3168 #[test]
3169 fn scroll_down_with_single_row() {
3170 let mut state = TableState::default();
3171 state.scroll_down(5, 1);
3172 assert_eq!(state.offset, 0);
3173 }
3174
3175 #[test]
3176 fn mouse_click_on_row_exceeding_row_count() {
3177 let mut state = TableState::default();
3179 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
3180 let hit = Some((HitId::new(1), HitRegion::Content, 100u64));
3181 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
3182 assert_eq!(result, MouseResult::Ignored);
3183 assert_eq!(state.selected, None);
3184 }
3185
3186 #[test]
3187 fn mouse_right_click_ignored() {
3188 let mut state = TableState::default();
3189 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Right), 0, 0);
3190 let hit = Some((HitId::new(1), HitRegion::Content, 2u64));
3191 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
3192 assert_eq!(result, MouseResult::Ignored);
3193 }
3194
3195 #[test]
3196 fn mouse_hover_on_row_exceeding_row_count() {
3197 let mut state = TableState::default();
3198 let event = MouseEvent::new(MouseEventKind::Moved, 0, 0);
3199 let hit = Some((HitId::new(1), HitRegion::Content, 100u64));
3200 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
3201 assert_eq!(result, MouseResult::Ignored);
3203 assert_eq!(state.hovered, None);
3204 }
3205
3206 #[test]
3207 fn select_deselect_preserves_offset_then_reselect() {
3208 let mut state = TableState {
3209 offset: 15,
3210 ..Default::default()
3211 };
3212 state.select(Some(20));
3213 assert_eq!(state.selected, Some(20));
3214 assert_eq!(state.offset, 15); state.select(None);
3217 assert_eq!(state.offset, 15); state.select(Some(3));
3220 assert_eq!(state.selected, Some(3));
3221 assert_eq!(state.offset, 15); }
3223
3224 #[test]
3225 fn offset_clamped_when_rows_empty() {
3226 let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
3227 let area = Rect::new(0, 0, 5, 3);
3228 let mut pool = GraphemePool::new();
3229 let mut frame = Frame::new(5, 3, &mut pool);
3230 let mut state = TableState {
3231 offset: 999,
3232 ..Default::default()
3233 };
3234 StatefulWidget::render(&table, area, &mut frame, &mut state);
3235 assert_eq!(state.offset, 0);
3236 }
3237
3238 #[test]
3239 fn selection_clamps_when_rows_empty() {
3240 let table = Table::new(Vec::<Row>::new(), [Constraint::Fixed(5)]);
3241 let area = Rect::new(0, 0, 5, 3);
3242 let mut pool = GraphemePool::new();
3243 let mut frame = Frame::new(5, 3, &mut pool);
3244 let mut state = TableState {
3245 selected: Some(5),
3246 ..Default::default()
3247 };
3248 StatefulWidget::render(&table, area, &mut frame, &mut state);
3249 assert_eq!(state.selected, None);
3250 }
3251
3252 #[test]
3253 fn header_with_bottom_margin_offsets_rows() {
3254 let header = Row::new(["H"]).bottom_margin(2);
3255 let table = Table::new([Row::new(["D"])], [Constraint::Fixed(3)]).header(header);
3256
3257 let area = Rect::new(0, 0, 3, 5);
3258 let mut pool = GraphemePool::new();
3259 let mut frame = Frame::new(3, 5, &mut pool);
3260 Widget::render(&table, area, &mut frame);
3261
3262 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
3264 assert_eq!(cell_char(&frame.buffer, 0, 3), Some('D'));
3265 }
3266
3267 #[test]
3268 fn block_plus_header_fill_entire_area() {
3269 let header = Row::new(["H"]);
3272 let table = Table::new([Row::new(["X"])], [Constraint::Fixed(3)])
3273 .block(Block::bordered())
3274 .header(header);
3275
3276 let area = Rect::new(0, 0, 5, 5);
3277 let mut pool = GraphemePool::new();
3278 let mut frame = Frame::new(5, 5, &mut pool);
3279 Widget::render(&table, area, &mut frame);
3280
3281 assert_eq!(cell_char(&frame.buffer, 2, 2), Some('H'));
3283 let data_rendered =
3285 (0..5).any(|x| (0..5).any(|y| cell_char(&frame.buffer, x, y) == Some('X')));
3286 assert!(!data_rendered);
3287 }
3288
3289 #[test]
3290 fn min_constraint_measure() {
3291 let table = Table::new([Row::new(["AB"])], [Constraint::Min(10)]);
3292 let c = table.measure(Size::MAX);
3293 assert_eq!(c.preferred.width, 2);
3295 assert_eq!(c.preferred.height, 1);
3296 }
3297
3298 #[test]
3299 fn percentage_constraint_render() {
3300 let table = Table::new(
3302 [Row::new(["A", "B"])],
3303 [Constraint::Percentage(50.0), Constraint::Percentage(50.0)],
3304 );
3305 let area = Rect::new(0, 0, 20, 1);
3306 let mut pool = GraphemePool::new();
3307 let mut frame = Frame::new(20, 1, &mut pool);
3308 Widget::render(&table, area, &mut frame);
3309
3310 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
3311 }
3312
3313 #[test]
3314 fn fit_content_constraint_measure() {
3315 let table = Table::new(
3316 [Row::new(["Hello", "World"])],
3317 [Constraint::FitContent, Constraint::FitContent],
3318 )
3319 .column_spacing(1);
3320
3321 let c = table.measure(Size::MAX);
3322 assert_eq!(c.preferred.width, 11);
3324 }
3325
3326 #[test]
3327 fn measure_with_block_adds_overhead() {
3328 let table_no_block = Table::new([Row::new(["X"])], [Constraint::Fixed(3)]);
3329 let table_with_block =
3330 Table::new([Row::new(["X"])], [Constraint::Fixed(3)]).block(Block::bordered());
3331
3332 let c_no = table_no_block.measure(Size::MAX);
3333 let c_with = table_with_block.measure(Size::MAX);
3334
3335 assert_eq!(c_with.preferred.width, c_no.preferred.width + 4);
3337 assert_eq!(c_with.preferred.height, c_no.preferred.height + 4);
3338 }
3339
3340 #[test]
3341 fn variable_height_rows_selection_scrolls_down() {
3342 let rows = vec![
3345 Row::new(["A"]),
3346 Row::new(["B"]),
3347 Row::new(["C"]).height(5),
3348 Row::new(["D"]),
3349 Row::new(["E"]),
3350 ];
3351 let table = Table::new(rows, [Constraint::Fixed(5)]);
3352 let area = Rect::new(0, 0, 5, 4);
3353 let mut pool = GraphemePool::new();
3354 let mut frame = Frame::new(5, 4, &mut pool);
3355 let mut state = TableState {
3356 selected: Some(4),
3357 ..Default::default()
3358 };
3359 StatefulWidget::render(&table, area, &mut frame, &mut state);
3360
3361 assert!(state.offset > 0);
3363 assert_eq!(state.selected, Some(4));
3364 }
3365
3366 #[test]
3367 fn many_rows_with_margins_viewport_clamping() {
3368 let rows: Vec<Row> = (0..20)
3371 .map(|i| Row::new([format!("R{i}")]).bottom_margin(1))
3372 .collect();
3373 let table = Table::new(rows, [Constraint::Fixed(5)]);
3374 let area = Rect::new(0, 0, 5, 5);
3375 let mut pool = GraphemePool::new();
3376 let mut frame = Frame::new(5, 5, &mut pool);
3377 let mut state = TableState {
3378 offset: 19,
3379 ..Default::default()
3380 };
3381 StatefulWidget::render(&table, area, &mut frame, &mut state);
3382
3383 assert!(state.offset < 19);
3385 }
3386
3387 #[test]
3388 fn render_area_width_one() {
3389 let table = Table::new([Row::new(["Hello"])], [Constraint::Fixed(5)]);
3391 let area = Rect::new(0, 0, 1, 1);
3392 let mut pool = GraphemePool::new();
3393 let mut frame = Frame::new(1, 1, &mut pool);
3394 Widget::render(&table, area, &mut frame);
3395
3396 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('H'));
3397 }
3398
3399 #[test]
3400 fn render_area_height_one() {
3401 let table = Table::new([Row::new(["A"]), Row::new(["B"])], [Constraint::Fixed(3)]);
3403 let area = Rect::new(0, 0, 3, 1);
3404 let mut pool = GraphemePool::new();
3405 let mut frame = Frame::new(3, 1, &mut pool);
3406 Widget::render(&table, area, &mut frame);
3407
3408 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('A'));
3409 }
3410
3411 #[test]
3412 fn hit_regions_with_offset() {
3413 let table = Table::new(
3415 (0..10).map(|i| Row::new([format!("R{i}")])),
3416 [Constraint::Fixed(5)],
3417 )
3418 .hit_id(HitId::new(42));
3419
3420 let area = Rect::new(0, 0, 5, 3);
3421 let mut pool = GraphemePool::new();
3422 let mut frame = Frame::with_hit_grid(5, 3, &mut pool);
3423 let mut state = TableState {
3424 offset: 5,
3425 ..Default::default()
3426 };
3427 StatefulWidget::render(&table, area, &mut frame, &mut state);
3428
3429 let hit0 = frame.hit_test(2, 0);
3431 assert_eq!(hit0, Some((HitId::new(42), HitRegion::Content, 5)));
3432
3433 let hit1 = frame.hit_test(2, 1);
3434 assert_eq!(hit1, Some((HitId::new(42), HitRegion::Content, 6)));
3435 }
3436
3437 #[test]
3438 fn table_state_sort_defaults() {
3439 let state = TableState::default();
3440 assert_eq!(state.sort_column(), None);
3441 assert!(!state.sort_ascending());
3442 assert!(state.filter().is_empty());
3443 }
3444
3445 #[test]
3446 fn table_state_set_sort_toggle() {
3447 let mut state = TableState::default();
3448 state.set_sort(Some(0), true);
3449 assert_eq!(state.sort_column(), Some(0));
3450 assert!(state.sort_ascending());
3451
3452 state.set_sort(Some(0), false);
3454 assert!(!state.sort_ascending());
3455
3456 state.set_sort(Some(3), true);
3458 assert_eq!(state.sort_column(), Some(3));
3459
3460 state.set_sort(None, false);
3462 assert_eq!(state.sort_column(), None);
3463 }
3464
3465 #[test]
3466 fn table_persist_round_trip_preserves_hovered_none() {
3467 let mut state = TableState::default().with_persistence_id("t");
3468 state.select(Some(3));
3469 state.hovered = Some(7);
3470 state.offset = 2;
3471
3472 let saved = state.save_state();
3473 state.restore_state(saved);
3474
3475 assert_eq!(state.hovered, None);
3477 assert_eq!(state.selected, Some(3));
3478 assert_eq!(state.offset, 2);
3479 }
3480
3481 #[test]
3482 fn undo_snapshot_clears_hovered() {
3483 let mut state = TableState::default();
3484 state.select(Some(2));
3485 state.hovered = Some(5);
3486
3487 let snap = state.create_snapshot();
3488
3489 state.select(Some(9));
3491 state.hovered = Some(8);
3492
3493 assert!(state.restore_snapshot(&*snap));
3495 assert_eq!(state.selected, Some(2));
3496 assert_eq!(state.hovered, None);
3498 }
3499
3500 #[test]
3501 fn wide_chars_in_render() {
3502 let table = Table::new([Row::new(["界界界"])], [Constraint::Fixed(4)]);
3505 let area = Rect::new(0, 0, 4, 1);
3506 let mut pool = GraphemePool::new();
3507 let mut frame = Frame::new(4, 1, &mut pool);
3508 Widget::render(&table, area, &mut frame);
3509
3510 let cell = frame.buffer.get(0, 0).unwrap();
3513 assert!(
3514 !cell.content.is_empty(),
3515 "first cell should contain CJK content, not be empty"
3516 );
3517 let cell1 = frame.buffer.get(1, 0).unwrap();
3519 assert!(
3520 cell1.content.is_continuation(),
3521 "second cell should be continuation of wide char"
3522 );
3523 }
3524
3525 #[test]
3526 fn empty_row_cells() {
3527 let table = Table::new(
3529 [Row::new(["", "", ""])],
3530 [
3531 Constraint::Fixed(3),
3532 Constraint::Fixed(3),
3533 Constraint::Fixed(3),
3534 ],
3535 );
3536 let area = Rect::new(0, 0, 11, 1);
3537 let mut pool = GraphemePool::new();
3538 let mut frame = Frame::new(11, 1, &mut pool);
3539 Widget::render(&table, area, &mut frame);
3540 }
3542
3543 #[test]
3544 fn measure_with_many_rows_saturates() {
3545 let rows: Vec<Row> = (0..10000).map(|_| Row::new(["X"]).height(100)).collect();
3547 let table = Table::new(rows, [Constraint::Fixed(3)]);
3548 let c = table.measure(Size::MAX);
3549
3550 assert!(c.preferred.height > 0);
3552 }
3553
3554 #[test]
3555 fn variable_height_rows_respect_viewport_visible_range() {
3556 let rows = vec![
3557 Row::new(["R0"]),
3558 Row::new(["R1"]).height(2),
3559 Row::new(["R2"]),
3560 Row::new(["R3"]),
3561 ];
3562 let table = Table::new(rows, [Constraint::Fixed(4)]);
3563 let area = Rect::new(0, 0, 4, 3);
3564 let mut pool = GraphemePool::new();
3565 let mut frame = Frame::new(4, 3, &mut pool);
3566 let mut state = TableState {
3567 offset: 1,
3568 ..Default::default()
3569 };
3570
3571 StatefulWidget::render(&table, area, &mut frame, &mut state);
3572
3573 assert_eq!(state.offset, 1);
3574 assert_eq!(row_text(&frame.buffer, 0), "R1");
3575 assert_eq!(row_text(&frame.buffer, 1), "");
3576 assert_eq!(row_text(&frame.buffer, 2), "R2");
3577 }
3578
3579 #[test]
3580 fn render_100k_rows_stays_within_8ms_frame_budget() {
3581 use std::time::{Duration, Instant};
3582
3583 let rows: Vec<Row> = (0..100_000).map(|_| Row::new(["row"])).collect();
3584 let table = Table::new(rows, [Constraint::Fixed(12)]);
3585 let area = Rect::new(0, 0, 12, 24);
3586 let mut state = TableState {
3587 offset: 50_000,
3588 ..Default::default()
3589 };
3590 let mut pool = GraphemePool::new();
3591
3592 let mut warmup = Frame::new(12, 24, &mut pool);
3594 StatefulWidget::render(&table, area, &mut warmup, &mut state);
3595
3596 let iterations = 20u32;
3597 let start = Instant::now();
3598 for _ in 0..iterations {
3599 let mut frame = Frame::new(12, 24, &mut pool);
3600 StatefulWidget::render(&table, area, &mut frame, &mut state);
3601 }
3602 let per_frame = start.elapsed() / iterations;
3603
3604 assert!(
3605 per_frame <= Duration::from_millis(8),
3606 "100k-row table render exceeded 8ms budget: {per_frame:?}"
3607 );
3608 }
3609
3610 #[cfg(feature = "tracing")]
3611 #[test]
3612 fn tracing_table_render_span_reports_row_counts() {
3613 let trace_state = Arc::new(Mutex::new(TableTraceState::default()));
3614 let _trace_test_guard = crate::tracing_test_support::acquire();
3615 let subscriber = tracing_subscriber::registry().with(TableTraceCapture {
3616 state: Arc::clone(&trace_state),
3617 });
3618 let _guard = tracing::subscriber::set_default(subscriber);
3619 tracing::callsite::rebuild_interest_cache();
3620
3621 let rows: Vec<Row> = (0..20).map(|i| Row::new([format!("R{i}")])).collect();
3622 let table = Table::new(rows, [Constraint::Fixed(6)]);
3623 let area = Rect::new(0, 0, 6, 4);
3624 let mut state = TableState {
3625 offset: 3,
3626 ..Default::default()
3627 };
3628 let mut pool = GraphemePool::new();
3629 let mut frame = Frame::new(6, 4, &mut pool);
3630 tracing::callsite::rebuild_interest_cache();
3633 StatefulWidget::render(&table, area, &mut frame, &mut state);
3634
3635 tracing::callsite::rebuild_interest_cache();
3636 let snapshot = trace_state.lock().expect("table trace state lock");
3637 assert!(
3638 snapshot.span_count >= 1,
3639 "expected at least one table.render span, got {}",
3640 snapshot.span_count
3641 );
3642 assert!(
3643 snapshot.has_total_rows_field,
3644 "table.render span missing total_rows field"
3645 );
3646 assert!(
3647 snapshot.has_rendered_rows_field,
3648 "table.render span missing rendered_rows field"
3649 );
3650 assert!(
3651 snapshot.total_rows.contains(&20),
3652 "expected total_rows=20 in span fields, got {:?}",
3653 snapshot.total_rows
3654 );
3655 assert!(
3656 snapshot.rendered_rows.iter().any(|&n| n > 0 && n <= 4),
3657 "expected rendered_rows between 1 and 4, got {:?}",
3658 snapshot.rendered_rows
3659 );
3660 }
3661
3662 #[test]
3663 fn stripe_period_zero_disables_alt_rows() {
3664 let row_fg = PackedRgba::WHITE;
3665 let row_alt_fg = PackedRgba::rgb(255, 255, 0);
3666 let theme = TableTheme::default()
3667 .with_stripe_period(0)
3668 .with_row(Style::new().fg(row_fg))
3669 .with_row_alt(Style::new().fg(row_alt_fg));
3670
3671 let rows = (0..6).map(|i| Row::new([format!("r{i}")]));
3672 let table = Table::new(rows, [Constraint::Fixed(10)]).theme(theme);
3673 let area = Rect::new(0, 0, 10, 6);
3674 let mut pool = GraphemePool::new();
3675 let mut frame = Frame::new(10, 6, &mut pool);
3676 Widget::render(&table, area, &mut frame);
3677
3678 for y in 0..6 {
3679 assert_eq!(
3680 cell_fg(&frame.buffer, 0, y),
3681 Some(row_fg),
3682 "row {y} cell fg should be row_fg when stripe_period is 0"
3683 );
3684 }
3685 }
3686
3687 #[test]
3688 fn stripe_period_two_matches_previous_behaviour() {
3689 let row_fg = PackedRgba::WHITE;
3690 let row_alt_fg = PackedRgba::rgb(255, 255, 0);
3691 let theme = TableTheme::default()
3692 .with_stripe_period(2)
3693 .with_row(Style::new().fg(row_fg))
3694 .with_row_alt(Style::new().fg(row_alt_fg));
3695
3696 let rows = (0..6).map(|i| Row::new([format!("r{i}")]));
3697 let table = Table::new(rows, [Constraint::Fixed(10)]).theme(theme);
3698 let area = Rect::new(0, 0, 10, 6);
3699 let mut pool = GraphemePool::new();
3700 let mut frame = Frame::new(10, 6, &mut pool);
3701 Widget::render(&table, area, &mut frame);
3702
3703 for y in 0..6 {
3704 let expected_fg = if y % 2 == 1 { row_alt_fg } else { row_fg };
3705 assert_eq!(
3706 cell_fg(&frame.buffer, 0, y),
3707 Some(expected_fg),
3708 "row {y} cell fg unexpected for stripe_period 2"
3709 );
3710 }
3711 }
3712
3713 #[test]
3714 fn stripe_period_three_pattern() {
3715 let row_fg = PackedRgba::WHITE;
3716 let row_alt_fg = PackedRgba::rgb(255, 255, 0);
3717 let theme = TableTheme::default()
3718 .with_stripe_period(3)
3719 .with_row(Style::new().fg(row_fg))
3720 .with_row_alt(Style::new().fg(row_alt_fg));
3721
3722 let rows = (0..6).map(|i| Row::new([format!("r{i}")]));
3723 let table = Table::new(rows, [Constraint::Fixed(10)]).theme(theme);
3724 let area = Rect::new(0, 0, 10, 6);
3725 let mut pool = GraphemePool::new();
3726 let mut frame = Frame::new(10, 6, &mut pool);
3727 Widget::render(&table, area, &mut frame);
3728
3729 for y in 0..6 {
3731 let expected_fg = if y % 3 == 2 { row_alt_fg } else { row_fg };
3732 assert_eq!(
3733 cell_fg(&frame.buffer, 0, y),
3734 Some(expected_fg),
3735 "row {y} cell fg unexpected for stripe_period 3"
3736 );
3737 }
3738 }
3739
3740 #[test]
3741 fn header_style_applied_to_header_row() {
3742 let cyan = PackedRgba::rgb(0, 205, 205);
3743 let theme = TableTheme::default()
3744 .with_header_style(Style::new().bold().fg(cyan))
3745 .with_row(Style::new().fg(PackedRgba::WHITE));
3746
3747 let table = Table::new([Row::new(["B0"])], [Constraint::Fixed(10)])
3748 .header(Row::new(["H0"]))
3749 .theme(theme);
3750
3751 let area = Rect::new(0, 0, 10, 2);
3752 let mut pool = GraphemePool::new();
3753 let mut frame = Frame::new(10, 2, &mut pool);
3754 Widget::render(&table, area, &mut frame);
3755
3756 let header_cell = frame.buffer.get(0, 0).copied().unwrap();
3758 assert_eq!(header_cell.fg, cyan);
3759 assert!(
3760 header_cell
3761 .attrs
3762 .has_flag(ftui_render::cell::StyleFlags::BOLD)
3763 );
3764
3765 let body_cell = frame.buffer.get(0, 1).copied().unwrap();
3767 assert_eq!(body_cell.fg, PackedRgba::WHITE);
3768 assert!(
3769 !body_cell
3770 .attrs
3771 .has_flag(ftui_render::cell::StyleFlags::BOLD)
3772 );
3773 }
3774
3775 #[test]
3776 fn selection_style_over_stripe() {
3777 let stripe_bg = PackedRgba::rgb(30, 30, 30);
3778 let selected_bg = PackedRgba::rgb(100, 100, 0);
3779
3780 let theme = TableTheme::default()
3781 .with_stripe_period(2)
3782 .with_row_alt(Style::new().bg(stripe_bg))
3783 .with_selection_style(Style::new().bg(selected_bg));
3784
3785 let rows = (0..4).map(|i| Row::new([format!("r{i}")]));
3786 let table = Table::new(rows, [Constraint::Fixed(10)]).theme(theme);
3787
3788 let area = Rect::new(0, 0, 10, 4);
3789 let mut pool = GraphemePool::new();
3790 let mut frame = Frame::new(10, 4, &mut pool);
3791 let mut state = TableState::default();
3792 state.select(Some(1)); StatefulWidget::render(&table, area, &mut frame, &mut state);
3795
3796 let r1_cell = frame.buffer.get(0, 1).copied().unwrap();
3797 assert_eq!(
3798 r1_cell.bg, selected_bg,
3799 "selected row bg should override stripe bg"
3800 );
3801 }
3802
3803 #[test]
3804 fn truncate_clip() {
3805 let table = Table::new([Row::new(["abcdef"])], [Constraint::Fixed(4)])
3806 .with_column_truncation(0, Truncate::Clip);
3807
3808 let area = Rect::new(0, 0, 4, 1);
3809 let mut pool = GraphemePool::new();
3810 let mut frame = Frame::new(4, 1, &mut pool);
3811 Widget::render(&table, area, &mut frame);
3812
3813 assert_eq!(raw_row_text(&frame.buffer, 0), "abcd");
3814 }
3815
3816 #[test]
3817 fn truncate_ellipsis_cjk_width() {
3818 let table = Table::new([Row::new(["日本語テキスト"])], [Constraint::Fixed(6)])
3822 .with_column_truncation(0, Truncate::Ellipsis);
3823
3824 let area = Rect::new(0, 0, 6, 1);
3825 let mut pool = GraphemePool::new();
3826 let mut frame = Frame::new(6, 1, &mut pool);
3827 Widget::render(&table, area, &mut frame);
3828
3829 let c4 = frame.buffer.get(4, 0).and_then(|c| c.content.as_char());
3830 assert_eq!(c4, Some('…'), "cell 4 should be ellipsis glyph");
3831 let c5 = frame.buffer.get(5, 0).and_then(|c| c.content.as_char());
3832 assert_eq!(
3833 c5,
3834 Some(' '),
3835 "cell 5 should be trailing blank cell, not a split half glyph"
3836 );
3837 }
3838
3839 #[test]
3840 fn truncate_ellipsis_ascii_fallback() {
3841 let theme = TableTheme::preset(TablePresetId::TerminalClassic);
3845 let table = Table::new([Row::new(["abcdef"])], [Constraint::Fixed(5)])
3846 .theme(theme)
3847 .with_column_truncation(0, Truncate::Ellipsis);
3848
3849 let area = Rect::new(0, 0, 5, 1);
3850 let mut pool = GraphemePool::new();
3851 let mut frame = Frame::new(5, 1, &mut pool);
3852 Widget::render(&table, area, &mut frame);
3853
3854 assert_eq!(raw_row_text(&frame.buffer, 0), "ab...");
3855 }
3856
3857 #[test]
3858 fn truncate_wrap_increases_row_height() {
3859 let theme = TableTheme::default().with_row_height(2);
3860 let table = Table::new([Row::new(["abcdefgh"])], [Constraint::Fixed(4)])
3861 .theme(theme.clone())
3862 .with_column_truncation(0, Truncate::Wrap);
3863
3864 let area = Rect::new(0, 0, 4, 3);
3865 let mut pool = GraphemePool::new();
3866 let mut frame = Frame::new(4, 3, &mut pool);
3867 Widget::render(&table, area, &mut frame);
3868
3869 assert_eq!(raw_row_text(&frame.buffer, 0), "abcd");
3870 assert_eq!(raw_row_text(&frame.buffer, 1), "efgh");
3871
3872 let table_capped = Table::new([Row::new(["abcdefghijkl"])], [Constraint::Fixed(4)])
3874 .theme(theme)
3875 .with_column_truncation(0, Truncate::Wrap);
3876
3877 let mut frame2 = Frame::new(4, 3, &mut pool);
3878 Widget::render(&table_capped, area, &mut frame2);
3879 assert_eq!(raw_row_text(&frame2.buffer, 0), "abcd");
3880 assert_eq!(raw_row_text(&frame2.buffer, 1), "efgh");
3881 assert_eq!(raw_row_text(&frame2.buffer, 2), " "); }
3883
3884 #[test]
3885 fn align_right_unicode_width() {
3886 let table = Table::new([Row::new(["12😀"])], [Constraint::Fixed(8)])
3890 .with_column_alignment(0, Alignment::Right);
3891
3892 let area = Rect::new(0, 0, 8, 1);
3893 let mut pool = GraphemePool::new();
3894 let mut frame = Frame::new(8, 1, &mut pool);
3895 Widget::render(&table, area, &mut frame);
3896
3897 for x in 0..4 {
3898 assert_eq!(
3899 cell_char(&frame.buffer, x, 0),
3900 Some(' '),
3901 "cell {x} should be blank"
3902 );
3903 }
3904 assert_eq!(cell_char(&frame.buffer, 4, 0), Some('1'));
3905 assert_eq!(cell_char(&frame.buffer, 5, 0), Some('2'));
3906 assert!(
3908 frame
3909 .buffer
3910 .get(6, 0)
3911 .is_some_and(|c| c.content.is_grapheme())
3912 );
3913 assert!(
3915 frame
3916 .buffer
3917 .get(7, 0)
3918 .is_some_and(|c| c.content.is_continuation())
3919 );
3920 }
3921
3922 #[test]
3923 fn align_center_odd_padding() {
3924 let table = Table::new([Row::new(["ab"])], [Constraint::Fixed(7)])
3926 .with_column_alignment(0, Alignment::Center);
3927
3928 let area = Rect::new(0, 0, 7, 1);
3929 let mut pool = GraphemePool::new();
3930 let mut frame = Frame::new(7, 1, &mut pool);
3931 Widget::render(&table, area, &mut frame);
3932
3933 assert_eq!(cell_char(&frame.buffer, 0, 0), Some(' '));
3934 assert_eq!(cell_char(&frame.buffer, 1, 0), Some(' '));
3935 assert_eq!(cell_char(&frame.buffer, 2, 0), Some('a'));
3936 assert_eq!(cell_char(&frame.buffer, 3, 0), Some('b'));
3937 assert_eq!(cell_char(&frame.buffer, 4, 0), Some(' '));
3938 assert_eq!(cell_char(&frame.buffer, 5, 0), Some(' '));
3939 assert_eq!(cell_char(&frame.buffer, 6, 0), Some(' '));
3940 }
3941
3942 #[test]
3943 fn column_spec_out_of_range_is_ignored() {
3944 let table = Table::new(
3945 [Row::new(["c0", "c1"])],
3946 [Constraint::Fixed(5), Constraint::Fixed(5)],
3947 )
3948 .with_column_alignment(9, Alignment::Right);
3949
3950 let area = Rect::new(0, 0, 11, 1);
3951 let mut pool = GraphemePool::new();
3952 let mut frame = Frame::new(11, 1, &mut pool);
3953 Widget::render(&table, area, &mut frame);
3955
3956 assert_eq!(cell_char(&frame.buffer, 0, 0), Some('c'));
3957 assert_eq!(cell_char(&frame.buffer, 1, 0), Some('0'));
3958 }
3959
3960 use proptest::prelude::*;
3961
3962 fn prop_unicode_strategy() -> impl Strategy<Value = String> {
3963 let ascii = "[a-zA-Z0-9 _-]{1,15}";
3964 let cjk = "[\\u{4e00}-\\u{4e20}]{1,6}";
3965 let emoji = prop_oneof![
3966 Just("😀".to_string()),
3967 Just("🎉".to_string()),
3968 Just("🚀".to_string()),
3969 Just("🦀".to_string()),
3970 Just("✨".to_string()),
3971 ];
3972 let part = prop_oneof![
3973 3 => ascii.prop_map(String::from),
3974 2 => cjk.prop_map(String::from),
3975 1 => emoji,
3976 ];
3977 proptest::collection::vec(part, 1..=4).prop_map(|parts| parts.concat())
3978 }
3979
3980 proptest! {
3981 #![proptest_config(ProptestConfig::with_cases(256))]
3982 #[test]
3983 fn prop_truncation_never_exceeds_width(
3984 s in prop_unicode_strategy(),
3985 w in 1u16..=20u16,
3986 mode_idx in 0u8..3u8,
3987 ) {
3988 let mode = match mode_idx {
3989 0 => Truncate::Clip,
3990 1 => Truncate::Ellipsis,
3991 _ => Truncate::Wrap,
3992 };
3993
3994 let table = Table::new([Row::new([s])], [Constraint::Fixed(w)])
3995 .with_column_truncation(0, mode);
3996
3997 let area = Rect::new(0, 0, w + 4, 3);
3998 let mut pool = GraphemePool::new();
3999 let mut frame = Frame::new(w + 4, 3, &mut pool);
4000 Widget::render(&table, area, &mut frame);
4001
4002 for y in 0..3 {
4003 for x in w..frame.buffer.width() {
4004 let ch = frame.buffer.get(x, y).and_then(|c| c.content.as_char());
4005 prop_assert!(ch.is_none() || ch == Some(' '));
4006 }
4007 }
4008 }
4009 }
4010
4011 #[test]
4012 fn table_with_stylesheet_maps_roles() {
4013 let sheet = StyleSheet::new();
4014 let yellow = PackedRgba::rgb(255, 255, 0);
4015 let grey = PackedRgba::rgb(128, 128, 128);
4016
4017 sheet.define("table.header", Style::new().bold());
4018 sheet.define("table.row_alt", Style::new().fg(yellow));
4019 sheet.define("table.divider", Style::new().fg(grey));
4020
4021 let rows = [Row::new(["A"]), Row::new(["B"]), Row::new(["C"])];
4022 let widths = [Constraint::Fixed(10)];
4023 let table = Table::new(rows, widths)
4024 .header(Row::new(["H"]))
4025 .with_stylesheet(&sheet);
4026
4027 let area = Rect::new(0, 0, 10, 5);
4028 let mut pool = GraphemePool::new();
4029 let mut frame = Frame::new(10, 5, &mut pool);
4030 Widget::render(&table, area, &mut frame);
4031
4032 let header_cell = frame.buffer.get(0, 0).unwrap();
4034 assert!(
4035 header_cell
4036 .attrs
4037 .has_flag(ftui_render::cell::StyleFlags::BOLD)
4038 );
4039
4040 let row1_cell = frame.buffer.get(0, 2).unwrap();
4043 assert_eq!(row1_cell.fg, yellow);
4044
4045 assert_eq!(
4047 table.table_theme().row_selected,
4048 TableTheme::default().row_selected
4049 );
4050 }
4051
4052 #[test]
4053 fn table_stylesheet_prefix_isolates() {
4054 let sheet = StyleSheet::new();
4055 let cyan = PackedRgba::rgb(0, 255, 255);
4056 let magenta = PackedRgba::rgb(255, 0, 255);
4057
4058 sheet.define("tools.header", Style::new().fg(cyan));
4059 sheet.define("logs.header", Style::new().fg(magenta));
4060
4061 let rows1 = [Row::new(["A"])];
4062 let rows2 = [Row::new(["B"])];
4063 let widths = [Constraint::Fixed(10)];
4064
4065 let t1 = Table::new(rows1, widths)
4066 .header(Row::new(["H1"]))
4067 .with_stylesheet_prefix(&sheet, "tools");
4068
4069 let t2 = Table::new(rows2, widths)
4070 .header(Row::new(["H2"]))
4071 .with_stylesheet_prefix(&sheet, "logs");
4072
4073 assert_eq!(t1.table_theme().header.fg, Some(cyan));
4074 assert_eq!(t2.table_theme().header.fg, Some(magenta));
4075 }
4076
4077 #[test]
4078 fn table_stylesheet_missing_roles_keep_theme() {
4079 let sheet = StyleSheet::new();
4080 sheet.define("table.header", Style::new().bold());
4081
4082 let rows = [Row::new(["A"])];
4083 let widths = [Constraint::Fixed(10)];
4084 let table = Table::new(rows, widths).with_stylesheet(&sheet);
4085
4086 let default_theme = TableTheme::default();
4087 assert_eq!(table.table_theme().border, default_theme.border);
4088 assert_eq!(table.table_theme().row, default_theme.row);
4089 assert_eq!(table.table_theme().row_alt, default_theme.row_alt);
4090 assert_eq!(table.table_theme().row_selected, default_theme.row_selected);
4091 assert_eq!(table.table_theme().row_hover, default_theme.row_hover);
4092 assert_eq!(table.table_theme().divider, default_theme.divider);
4093 }
4094
4095 #[test]
4096 fn theme_column_gap_controls_column_spacing_unless_overridden() {
4097 let rows = [Row::new(["AA", "BB"])];
4098 let widths = [Constraint::Fixed(2), Constraint::Fixed(2)];
4099 let theme = TableTheme::modern().with_column_gap(3);
4100
4101 let table_from_theme = Table::new(rows.clone(), widths).theme(theme.clone());
4102 let mut pool = GraphemePool::new();
4103 let mut frame = Frame::new(10, 1, &mut pool);
4104 Widget::render(&table_from_theme, Rect::new(0, 0, 10, 1), &mut frame);
4105 assert_eq!(raw_row_text(&frame.buffer, 0), "AA│ BB ");
4106 assert_eq!(
4107 table_from_theme.measure(Size::new(10, 1)).preferred.width,
4108 7
4109 );
4110
4111 let table_overridden = Table::new(rows, widths).theme(theme).column_spacing(1);
4112 let mut frame2 = Frame::new(10, 1, &mut pool);
4113 Widget::render(&table_overridden, Rect::new(0, 0, 10, 1), &mut frame2);
4114 assert_eq!(raw_row_text(&frame2.buffer, 0), "AA│BB ");
4115 assert_eq!(
4116 table_overridden.measure(Size::new(10, 1)).preferred.width,
4117 5
4118 );
4119 }
4120
4121 #[test]
4122 fn theme_padding_insets_cells_and_expands_intrinsic_widths() {
4123 let rows = [Row::new(["ID", "Name"])];
4124 let widths = [Constraint::FitContent, Constraint::FitContent];
4125 let theme = TableTheme::modern().with_padding(2).with_column_gap(1);
4126
4127 let table = Table::new(rows, widths)
4128 .theme(theme)
4129 .use_theme_padding(true);
4130
4131 assert_eq!(table.measure(Size::new(20, 1)).preferred.width, 15);
4133
4134 let mut pool = GraphemePool::new();
4135 let mut frame = Frame::new(15, 1, &mut pool);
4136 Widget::render(&table, Rect::new(0, 0, 15, 1), &mut frame);
4137 assert_eq!(raw_row_text(&frame.buffer, 0), " ID │ Name ");
4138 }
4139
4140 #[test]
4141 fn table_uses_arena_when_present() {
4142 let rows = [
4143 Row::new(["worker-00", "running", "40 us"]),
4144 Row::new(["worker-01", "idle", "47 us"]),
4145 ];
4146 let widths = [
4147 Constraint::Fixed(12),
4148 Constraint::Fixed(10),
4149 Constraint::Fill,
4150 ];
4151 let table = Table::new(rows, widths).header(Row::new(["Worker", "State", "Latency"]));
4152 let mut pool = GraphemePool::new();
4153 let arena = ftui_core::arena::FrameArena::new(0);
4154 assert_eq!(arena.allocated_bytes(), 0);
4155 let mut frame = Frame::new(40, 6, &mut pool);
4156 frame.set_arena(&arena);
4157 let mut state = TableState::default();
4158 StatefulWidget::render(&table, Rect::new(0, 0, 40, 6), &mut frame, &mut state);
4159 assert!(
4160 arena.allocated_bytes() > 0,
4161 "expected Table::render to allocate scratch rects/indices from FrameArena"
4162 );
4163 }
4164}