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