1#![forbid(unsafe_code)]
2
3use crate::mouse::MouseResult;
9use crate::{StatefulWidget, Widget, clear_text_row, draw_text_span};
10use ftui_core::event::{KeyCode, KeyEvent, KeyEventKind, MouseButton, MouseEvent, MouseEventKind};
11use ftui_core::geometry::Rect;
12use ftui_render::frame::{Frame, HitId, HitRegion};
13use ftui_style::Style;
14use ftui_text::display_width;
15#[cfg(feature = "tracing")]
16use web_time::Instant;
17
18#[derive(Debug, Clone, PartialEq, Eq)]
20pub struct Tab<'a> {
21 title: String,
22 style: Style,
23 closable: bool,
24 _marker: std::marker::PhantomData<&'a ()>,
25}
26
27impl<'a> Tab<'a> {
28 #[must_use]
30 pub fn new(title: impl Into<String>) -> Self {
31 Self {
32 title: title.into(),
33 style: Style::default(),
34 closable: false,
35 _marker: std::marker::PhantomData,
36 }
37 }
38
39 #[must_use]
41 pub fn style(mut self, style: Style) -> Self {
42 self.style = style;
43 self
44 }
45
46 #[must_use]
48 pub fn closable(mut self, closable: bool) -> Self {
49 self.closable = closable;
50 self
51 }
52
53 #[must_use]
55 pub fn title(&self) -> &str {
56 &self.title
57 }
58
59 #[must_use]
61 pub const fn is_closable(&self) -> bool {
62 self.closable
63 }
64}
65
66#[derive(Debug, Clone, Default, PartialEq, Eq)]
68pub struct TabsState {
69 pub active: usize,
71 pub offset: usize,
73}
74
75impl TabsState {
76 pub fn select(&mut self, index: usize, tab_count: usize) -> bool {
78 if tab_count == 0 {
79 self.active = 0;
80 self.offset = 0;
81 return false;
82 }
83 let next = index.min(tab_count.saturating_sub(1));
84 if self.active == next {
85 return false;
86 }
87 #[cfg(feature = "tracing")]
88 let old = self.active;
89 self.active = next;
90 if self.active < self.offset {
91 self.offset = self.active;
92 }
93 #[cfg(feature = "tracing")]
94 Self::log_switch("select", old, self.active);
95 true
96 }
97
98 pub fn next(&mut self, tab_count: usize) -> bool {
100 if tab_count == 0 {
101 return false;
102 }
103 self.select(
104 self.active
105 .saturating_add(1)
106 .min(tab_count.saturating_sub(1)),
107 tab_count,
108 )
109 }
110
111 pub fn previous(&mut self, tab_count: usize) -> bool {
113 if tab_count == 0 {
114 return false;
115 }
116 self.select(self.active.saturating_sub(1), tab_count)
117 }
118
119 pub fn handle_key(&mut self, key: &KeyEvent, tab_count: usize) -> bool {
129 if key.kind == KeyEventKind::Release {
130 return false;
131 }
132 match key.code {
133 KeyCode::Left => self.previous(tab_count),
134 KeyCode::Right => self.next(tab_count),
135 KeyCode::Char(ch) if ('1'..='9').contains(&ch) => {
136 let idx = ch as usize - '1' as usize;
137 if idx >= tab_count {
138 false
139 } else {
140 self.select(idx, tab_count)
141 }
142 }
143 _ => false,
144 }
145 }
146
147 pub fn handle_mouse(
151 &mut self,
152 event: &MouseEvent,
153 hit: Option<(HitId, HitRegion, u64)>,
154 expected_id: HitId,
155 tab_count: usize,
156 ) -> MouseResult {
157 match event.kind {
158 MouseEventKind::Down(MouseButton::Left) => {
159 if let Some((id, HitRegion::Content, data)) = hit
160 && id == expected_id
161 {
162 let idx = data as usize;
163 if idx < tab_count {
164 if self.active == idx {
165 return MouseResult::Activated(idx);
166 }
167 self.select(idx, tab_count);
168 return MouseResult::Selected(idx);
169 }
170 }
171 MouseResult::Ignored
172 }
173 _ => MouseResult::Ignored,
174 }
175 }
176
177 #[cfg(feature = "tracing")]
178 fn log_switch(reason: &str, from: usize, to: usize) {
179 tracing::debug!(message = "tabs.switch", reason, from, to);
180 }
181}
182
183#[derive(Debug, Clone, Default)]
185pub struct Tabs<'a> {
186 tabs: Vec<Tab<'a>>,
187 style: Style,
188 active_style: Style,
189 separator: &'a str,
190 close_marker: &'a str,
191 overflow_left_marker: &'a str,
192 overflow_right_marker: &'a str,
193 hit_id: Option<HitId>,
194}
195
196impl<'a> Tabs<'a> {
197 #[must_use]
199 pub fn new(tabs: impl IntoIterator<Item = Tab<'a>>) -> Self {
200 Self {
201 tabs: tabs.into_iter().collect(),
202 style: Style::default(),
203 active_style: Style::default(),
204 separator: " ",
205 close_marker: " x",
206 overflow_left_marker: "<",
207 overflow_right_marker: ">",
208 hit_id: None,
209 }
210 }
211
212 #[must_use]
214 pub fn style(mut self, style: Style) -> Self {
215 self.style = style;
216 self
217 }
218
219 #[must_use]
221 pub fn active_style(mut self, style: Style) -> Self {
222 self.active_style = style;
223 self
224 }
225
226 #[must_use]
228 pub fn separator(mut self, separator: &'a str) -> Self {
229 self.separator = separator;
230 self
231 }
232
233 #[must_use]
235 pub fn hit_id(mut self, id: HitId) -> Self {
236 self.hit_id = Some(id);
237 self
238 }
239
240 #[must_use]
242 pub fn tabs(&self) -> &[Tab<'a>] {
243 &self.tabs
244 }
245
246 fn tab_label(&self, tab: &Tab<'_>, active: bool) -> String {
247 let mut out = String::new();
248 if active {
249 out.push('[');
250 } else {
251 out.push(' ');
252 }
253 out.push_str(tab.title());
254 if tab.is_closable() {
255 out.push_str(self.close_marker);
256 }
257 if active {
258 out.push(']');
259 } else {
260 out.push(' ');
261 }
262 out
263 }
264
265 fn visible_end(&self, state: &TabsState, width: usize) -> usize {
266 if self.tabs.is_empty() || width == 0 {
267 return state.offset;
268 }
269 let sep_width = display_width(self.separator);
270 let mut used = 0usize;
271 let mut end = state.offset;
272
273 for idx in state.offset..self.tabs.len() {
274 let w = display_width(
275 self.tab_label(&self.tabs[idx], idx == state.active)
276 .as_str(),
277 );
278 let extra = if idx == state.offset { 0 } else { sep_width };
279 if end == state.offset {
280 used = w;
282 end = idx + 1;
283 if used > width {
284 break;
285 }
286 continue;
287 }
288 if used.saturating_add(extra).saturating_add(w) > width {
289 break;
290 }
291 used = used.saturating_add(extra).saturating_add(w);
292 end = idx + 1;
293 }
294
295 end.max((state.offset + 1).min(self.tabs.len()))
296 }
297
298 fn compute_visible_range(
299 &self,
300 state: &mut TabsState,
301 area_width: usize,
302 ) -> (usize, usize, bool, bool) {
303 if self.tabs.is_empty() || area_width == 0 {
304 state.active = 0;
305 state.offset = 0;
306 return (0, 0, false, false);
307 }
308 state.active = state.active.min(self.tabs.len().saturating_sub(1));
309 state.offset = state.offset.min(self.tabs.len().saturating_sub(1));
310 if state.active < state.offset {
311 state.offset = state.active;
312 }
313
314 let left_marker_w = display_width(self.overflow_left_marker);
315 let right_marker_w = display_width(self.overflow_right_marker);
316
317 let mut available_width = area_width;
318 let mut start = state.offset;
319 let mut end = self.visible_end(state, available_width);
320
321 if state.active >= end {
323 start = state.active;
324 state.offset = start;
325 end = self.visible_end(state, available_width);
326 }
327
328 for _ in 0..3 {
330 let overflow_left = start > 0;
331 let overflow_right = end < self.tabs.len();
332
333 let mut next_width = area_width;
334 if overflow_left {
335 next_width = next_width.saturating_sub(left_marker_w);
336 }
337 if overflow_right {
338 next_width = next_width.saturating_sub(right_marker_w);
339 }
340
341 if next_width == available_width {
342 break;
343 }
344 available_width = next_width;
345
346 end = self.visible_end(state, available_width);
348
349 if state.active >= end {
351 start = state.active;
352 state.offset = start;
353 end = self.visible_end(state, available_width);
354 }
355 }
356
357 let overflow_left = start > 0;
358 let overflow_right = end < self.tabs.len();
359 (start, end, overflow_left, overflow_right)
360 }
361
362 pub fn close_active(&mut self, state: &mut TabsState) -> Option<Tab<'a>> {
364 if self.tabs.is_empty() {
365 state.active = 0;
366 state.offset = 0;
367 return None;
368 }
369 state.active = state.active.min(self.tabs.len().saturating_sub(1));
370 if !self.tabs[state.active].is_closable() {
371 return None;
372 }
373 let removed = self.tabs.remove(state.active);
374 if self.tabs.is_empty() {
375 state.active = 0;
376 state.offset = 0;
377 } else if state.active >= self.tabs.len() {
378 state.active = self.tabs.len().saturating_sub(1);
379 state.offset = state.offset.min(state.active);
380 }
381 Some(removed)
382 }
383
384 pub fn move_active_left(&mut self, state: &mut TabsState) -> bool {
386 if self.tabs.len() < 2 || state.active == 0 || state.active >= self.tabs.len() {
387 return false;
388 }
389 self.tabs.swap(state.active, state.active - 1);
390 state.active -= 1;
391 state.offset = state.offset.min(state.active);
392 true
393 }
394
395 pub fn move_active_right(&mut self, state: &mut TabsState) -> bool {
397 if self.tabs.len() < 2 || state.active + 1 >= self.tabs.len() {
398 return false;
399 }
400 self.tabs.swap(state.active, state.active + 1);
401 state.active += 1;
402 true
403 }
404}
405
406impl StatefulWidget for Tabs<'_> {
407 type State = TabsState;
408
409 fn render(&self, area: Rect, frame: &mut Frame, state: &mut Self::State) {
410 #[cfg(feature = "tracing")]
411 let render_start = Instant::now();
412
413 if area.is_empty() || area.height == 0 {
414 return;
415 }
416 if frame.a11y_enabled() {
417 frame.push_a11y_nodes(ftui_a11y::Accessible::accessibility_nodes(self, area));
418 }
419
420 let deg = frame.buffer.degradation;
421 let base_style = if deg.apply_styling() {
422 self.style
423 } else {
424 Style::default()
425 };
426
427 clear_text_row(frame, area, base_style);
428
429 if !deg.render_content() || self.tabs.is_empty() {
430 return;
431 }
432
433 let (start, end, overflow_left, overflow_right) =
434 self.compute_visible_range(state, area.width as usize);
435
436 #[cfg(feature = "tracing")]
437 let tab_count = self.tabs.len();
438 #[cfg(feature = "tracing")]
439 let active_tab = state.active.min(self.tabs.len().saturating_sub(1));
440 #[cfg(feature = "tracing")]
441 let render_span = tracing::debug_span!(
442 "tabs.render",
443 tab_count,
444 active_tab,
445 overflow = overflow_left || overflow_right,
446 render_duration_us = tracing::field::Empty
447 );
448 #[cfg(feature = "tracing")]
449 let _render_guard = render_span.enter();
450
451 let mut left = area.x;
452 let mut right = area.right();
453 if overflow_left {
454 draw_text_span(
455 frame,
456 area.x,
457 area.y,
458 self.overflow_left_marker,
459 base_style,
460 area.right(),
461 );
462 left = left.saturating_add(display_width(self.overflow_left_marker) as u16);
463 }
464 if overflow_right {
465 right = right.saturating_sub(display_width(self.overflow_right_marker) as u16);
466 draw_text_span(
467 frame,
468 right,
469 area.y,
470 self.overflow_right_marker,
471 base_style,
472 area.right(),
473 );
474 }
475
476 let mut x = left;
477 for idx in start..end {
478 if x >= right {
479 break;
480 }
481 if idx > start && !self.separator.is_empty() {
482 x = draw_text_span(frame, x, area.y, self.separator, base_style, right);
483 if x >= right {
484 break;
485 }
486 }
487 let tab = &self.tabs[idx];
488 let label = self.tab_label(tab, idx == state.active);
489 let mut tab_style = base_style;
490 if deg.apply_styling() {
491 tab_style = self.style.merge(&tab.style);
492 if idx == state.active {
493 tab_style = self.active_style.merge(&tab_style);
494 }
495 }
496 let before = x;
497 x = draw_text_span(frame, x, area.y, &label, tab_style, right);
498 if let Some(id) = self.hit_id {
499 let width = x.saturating_sub(before).max(1);
500 frame.register_hit(
501 Rect::new(before, area.y, width, 1),
502 id,
503 HitRegion::Content,
504 idx as u64,
505 );
506 }
507 }
508
509 #[cfg(feature = "tracing")]
510 {
511 let elapsed_us = render_start.elapsed().as_micros() as u64;
512 render_span.record("render_duration_us", elapsed_us);
513 }
514 }
515}
516
517impl Widget for Tabs<'_> {
518 fn render(&self, area: Rect, frame: &mut Frame) {
519 let mut state = TabsState::default();
520 StatefulWidget::render(self, area, frame, &mut state);
521 }
522
523 fn is_essential(&self) -> bool {
524 true
525 }
526}
527
528impl ftui_a11y::Accessible for Tabs<'_> {
529 fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
530 use ftui_a11y::node::{A11yNodeInfo, A11yRole};
531
532 let base_id = crate::a11y_node_id(area);
533 let tab_count = self.tabs.len();
534 let child_ids: Vec<u64> = (0..tab_count).map(|i| base_id + 1 + i as u64).collect();
535
536 let group_node = A11yNodeInfo::new(base_id, A11yRole::Group, area)
537 .with_name(format!("{tab_count} tabs"))
538 .with_children(child_ids);
539
540 let mut nodes = vec![group_node];
541 for (i, tab) in self.tabs.iter().enumerate() {
542 let tab_id = base_id + 1 + i as u64;
543 nodes.push(
544 A11yNodeInfo::new(tab_id, A11yRole::Tab, area)
545 .with_name(&tab.title)
546 .with_parent(base_id),
547 );
548 }
549 nodes
550 }
551}
552
553#[cfg(test)]
554mod tests {
555 use super::*;
556 use ftui_core::event::{KeyCode, KeyEvent};
557 use ftui_render::budget::DegradationLevel;
558 use ftui_render::grapheme_pool::GraphemePool;
559 #[cfg(feature = "tracing")]
560 use std::sync::{Arc, Mutex};
561 #[cfg(feature = "tracing")]
562 use tracing::Subscriber;
563 #[cfg(feature = "tracing")]
564 use tracing_subscriber::Layer;
565 #[cfg(feature = "tracing")]
566 use tracing_subscriber::layer::{Context, SubscriberExt};
567
568 fn row_text(frame: &Frame, y: u16) -> String {
569 let mut out = String::new();
570 for x in 0..frame.buffer.width() {
571 let ch = frame
572 .buffer
573 .get(x, y)
574 .and_then(|cell| cell.content.as_char())
575 .unwrap_or(' ');
576 out.push(ch);
577 }
578 out
579 }
580
581 #[test]
582 fn tabs_render_basic() {
583 let tabs = Tabs::new(vec![Tab::new("One"), Tab::new("Two"), Tab::new("Three")]);
584 let mut state = TabsState::default();
585 state.select(1, 3);
586 let mut pool = GraphemePool::new();
587 let mut frame = Frame::new(30, 1, &mut pool);
588 StatefulWidget::render(&tabs, Rect::new(0, 0, 30, 1), &mut frame, &mut state);
589 let row = row_text(&frame, 0);
590 assert!(row.contains("[Two]"));
591 }
592
593 #[test]
594 fn tabs_keyboard_switching_arrows_and_numbers() {
595 let mut state = TabsState::default();
596 assert!(state.handle_key(&KeyEvent::new(KeyCode::Right), 4));
597 assert_eq!(state.active, 1);
598 assert!(state.handle_key(&KeyEvent::new(KeyCode::Left), 4));
599 assert_eq!(state.active, 0);
600 assert!(state.handle_key(&KeyEvent::new(KeyCode::Char('3')), 4));
601 assert_eq!(state.active, 2);
602 assert!(!state.handle_key(&KeyEvent::new(KeyCode::Char('9')), 4));
603 assert_eq!(state.active, 2);
604 }
605
606 #[test]
607 fn tabs_keyboard_ignores_key_release() {
608 use ftui_core::event::KeyEventKind;
610 let mut state = TabsState::default();
611 let right = KeyEvent::new(KeyCode::Right);
612 assert!(state.handle_key(&right, 4));
613 assert!(!state.handle_key(&right.with_kind(KeyEventKind::Release), 4));
614 assert_eq!(state.active, 1);
615 assert!(state.handle_key(&right.with_kind(KeyEventKind::Repeat), 4));
616 assert_eq!(state.active, 2);
617 }
618
619 #[test]
620 fn tabs_overflow_markers_render_when_needed() {
621 let tabs = Tabs::new((0..8).map(|i| Tab::new(format!("Tab{i}"))));
622 let mut state = TabsState::default();
623 state.select(0, 8);
624 let mut pool = GraphemePool::new();
625 let mut frame = Frame::new(12, 1, &mut pool);
626 StatefulWidget::render(&tabs, Rect::new(0, 0, 12, 1), &mut frame, &mut state);
627 assert_eq!(
628 frame.buffer.get(11, 0).and_then(|c| c.content.as_char()),
629 Some('>')
630 );
631
632 state.select(7, 8);
633 StatefulWidget::render(&tabs, Rect::new(0, 0, 12, 1), &mut frame, &mut state);
634 assert_eq!(
635 frame.buffer.get(0, 0).and_then(|c| c.content.as_char()),
636 Some('<')
637 );
638 }
639
640 #[test]
641 fn tabs_close_active_respects_closable() {
642 let mut tabs = Tabs::new(vec![
643 Tab::new("Pinned").closable(false),
644 Tab::new("Temp").closable(true),
645 ]);
646 let mut state = TabsState::default();
647 state.select(0, 2);
648 assert!(tabs.close_active(&mut state).is_none());
649 state.select(1, 2);
650 assert!(tabs.close_active(&mut state).is_some());
651 assert_eq!(tabs.tabs().len(), 1);
652 assert_eq!(tabs.tabs()[0].title(), "Pinned");
653 }
654
655 #[test]
656 fn tabs_reorder_active_left_and_right() {
657 let mut tabs = Tabs::new(vec![Tab::new("A"), Tab::new("B"), Tab::new("C")]);
658 let mut state = TabsState::default();
659 state.select(1, 3);
660 assert!(tabs.move_active_left(&mut state));
661 assert_eq!(state.active, 0);
662 assert_eq!(tabs.tabs()[0].title(), "B");
663 assert!(tabs.move_active_right(&mut state));
664 assert_eq!(state.active, 1);
665 assert_eq!(tabs.tabs()[1].title(), "B");
666 }
667
668 #[test]
669 fn tabs_hit_regions_encode_tab_index() {
670 let tabs = Tabs::new(vec![Tab::new("A"), Tab::new("B")]).hit_id(HitId::new(5));
671 let mut state = TabsState::default();
672 let mut pool = GraphemePool::new();
673 let mut frame = Frame::with_hit_grid(20, 1, &mut pool);
674 StatefulWidget::render(&tabs, Rect::new(0, 0, 20, 1), &mut frame, &mut state);
675 let hit_a = frame.hit_test(1, 0);
676 let hit_b = frame.hit_test(6, 0);
677 assert_eq!(hit_a.map(|(_, _, data)| data), Some(0));
678 assert_eq!(hit_b.map(|(_, _, data)| data), Some(1));
679 }
680
681 #[cfg(feature = "tracing")]
682 #[derive(Default)]
683 struct TabsTraceState {
684 saw_render_span: bool,
685 saw_switch_event: bool,
686 saw_duration_record: bool,
687 }
688
689 #[cfg(feature = "tracing")]
690 struct TabsTraceCapture {
691 state: Arc<Mutex<TabsTraceState>>,
692 }
693
694 #[cfg(feature = "tracing")]
695 impl<S> Layer<S> for TabsTraceCapture
696 where
697 S: Subscriber + for<'lookup> tracing_subscriber::registry::LookupSpan<'lookup>,
698 {
699 fn on_new_span(
700 &self,
701 attrs: &tracing::span::Attributes<'_>,
702 _id: &tracing::Id,
703 _ctx: Context<'_, S>,
704 ) {
705 if attrs.metadata().name() == "tabs.render" {
706 self.state.lock().expect("tabs trace lock").saw_render_span = true;
707 }
708 }
709
710 fn on_record(
711 &self,
712 id: &tracing::Id,
713 values: &tracing::span::Record<'_>,
714 ctx: Context<'_, S>,
715 ) {
716 let Some(span) = ctx.span(id) else {
717 return;
718 };
719 if span.metadata().name() != "tabs.render" {
720 return;
721 }
722 struct V {
723 saw: bool,
724 }
725 impl tracing::field::Visit for V {
726 fn record_u64(&mut self, field: &tracing::field::Field, _value: u64) {
727 if field.name() == "render_duration_us" {
728 self.saw = true;
729 }
730 }
731
732 fn record_debug(
733 &mut self,
734 _field: &tracing::field::Field,
735 _value: &dyn std::fmt::Debug,
736 ) {
737 }
738 }
739 let mut v = V { saw: false };
740 values.record(&mut v);
741 if v.saw {
742 self.state
743 .lock()
744 .expect("tabs trace lock")
745 .saw_duration_record = true;
746 }
747 }
748
749 fn on_event(&self, event: &tracing::Event<'_>, _ctx: Context<'_, S>) {
750 struct Msg {
751 message: Option<String>,
752 }
753 impl tracing::field::Visit for Msg {
754 fn record_str(&mut self, field: &tracing::field::Field, value: &str) {
755 if field.name() == "message" {
756 self.message = Some(value.to_string());
757 }
758 }
759
760 fn record_debug(
761 &mut self,
762 field: &tracing::field::Field,
763 value: &dyn std::fmt::Debug,
764 ) {
765 if field.name() == "message" {
766 self.message = Some(format!("{value:?}").trim_matches('"').to_string());
767 }
768 }
769 }
770 let mut msg = Msg { message: None };
771 event.record(&mut msg);
772 if msg.message.as_deref() == Some("tabs.switch") {
773 self.state.lock().expect("tabs trace lock").saw_switch_event = true;
774 }
775 }
776 }
777
778 #[cfg(feature = "tracing")]
779 #[test]
780 fn tabs_tracing_span_and_switch_event_emitted() {
781 let state = Arc::new(Mutex::new(TabsTraceState::default()));
782 let _trace_test_guard = crate::tracing_test_support::acquire();
783 let subscriber = tracing_subscriber::registry().with(TabsTraceCapture {
784 state: Arc::clone(&state),
785 });
786 let _guard = tracing::subscriber::set_default(subscriber);
787
788 let tabs = Tabs::new(vec![Tab::new("A"), Tab::new("B"), Tab::new("C")]);
789 let mut tabs_state = TabsState::default();
790 let mut pool = GraphemePool::new();
791 let mut frame = Frame::new(20, 1, &mut pool);
792 tracing::callsite::rebuild_interest_cache();
793 StatefulWidget::render(&tabs, Rect::new(0, 0, 20, 1), &mut frame, &mut tabs_state);
794 tracing::callsite::rebuild_interest_cache();
795 assert!(tabs_state.handle_key(&KeyEvent::new(KeyCode::Right), 3));
796 tracing::callsite::rebuild_interest_cache();
797
798 let snapshot = state.lock().expect("tabs trace lock");
799 assert!(snapshot.saw_render_span, "expected tabs.render span");
800 assert!(
801 snapshot.saw_duration_record,
802 "expected render_duration_us record"
803 );
804 assert!(
805 snapshot.saw_switch_event,
806 "expected tabs.switch debug event"
807 );
808 }
809
810 #[test]
813 fn tabs_select_zero_count_resets() {
814 let mut state = TabsState {
815 active: 3,
816 offset: 2,
817 };
818 assert!(!state.select(0, 0));
819 assert_eq!(state.active, 0);
820 assert_eq!(state.offset, 0);
821 }
822
823 #[test]
824 fn tabs_select_same_tab_returns_false() {
825 let mut state = TabsState::default();
826 state.select(2, 5);
827 assert!(!state.select(2, 5));
828 }
829
830 #[test]
831 fn tabs_select_out_of_range_clamps() {
832 let mut state = TabsState::default();
833 assert!(state.select(100, 5));
834 assert_eq!(state.active, 4); }
836
837 #[test]
838 fn tabs_select_updates_offset_when_active_before_offset() {
839 let mut state = TabsState {
840 active: 3,
841 offset: 3,
842 };
843 assert!(state.select(1, 5));
844 assert_eq!(state.active, 1);
845 assert_eq!(state.offset, 1); }
847
848 #[test]
849 fn tabs_next_at_last_tab_returns_false() {
850 let mut state = TabsState::default();
851 state.select(4, 5);
852 assert!(!state.next(5));
853 assert_eq!(state.active, 4);
854 }
855
856 #[test]
857 fn tabs_next_empty_returns_false() {
858 let mut state = TabsState::default();
859 assert!(!state.next(0));
860 }
861
862 #[test]
863 fn tabs_previous_at_first_tab_returns_false() {
864 let mut state = TabsState::default();
865 assert!(!state.previous(5));
866 assert_eq!(state.active, 0);
867 }
868
869 #[test]
870 fn tabs_previous_empty_returns_false() {
871 let mut state = TabsState::default();
872 assert!(!state.previous(0));
873 }
874
875 #[test]
876 fn tabs_handle_key_unhandled_returns_false() {
877 let mut state = TabsState::default();
878 assert!(!state.handle_key(&KeyEvent::new(KeyCode::Enter), 3));
879 assert!(!state.handle_key(&KeyEvent::new(KeyCode::Escape), 3));
880 assert!(!state.handle_key(&KeyEvent::new(KeyCode::Up), 3));
881 }
882
883 #[test]
884 fn tabs_handle_key_number_at_exact_tab_count_returns_false() {
885 let mut state = TabsState::default();
886 assert!(!state.handle_key(&KeyEvent::new(KeyCode::Char('4')), 3));
888 }
889
890 #[test]
891 fn tabs_handle_key_number_one_selects_first() {
892 let mut state = TabsState::default();
893 state.select(2, 5);
894 assert!(state.handle_key(&KeyEvent::new(KeyCode::Char('1')), 5));
895 assert_eq!(state.active, 0);
896 }
897
898 use crate::mouse::MouseResult;
901 use ftui_core::event::{MouseButton, MouseEvent, MouseEventKind};
902
903 #[test]
904 fn tabs_mouse_click_selects() {
905 let mut state = TabsState::default();
906 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 0);
907 let hit = Some((HitId::new(1), HitRegion::Content, 2u64));
908 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
909 assert_eq!(result, MouseResult::Selected(2));
910 assert_eq!(state.active, 2);
911 }
912
913 #[test]
914 fn tabs_mouse_click_same_tab_activates() {
915 let mut state = TabsState::default();
916 state.select(2, 5);
917 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 0);
918 let hit = Some((HitId::new(1), HitRegion::Content, 2u64));
919 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
920 assert_eq!(result, MouseResult::Activated(2));
921 }
922
923 #[test]
924 fn tabs_mouse_click_wrong_id_ignored() {
925 let mut state = TabsState::default();
926 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 0);
927 let hit = Some((HitId::new(99), HitRegion::Content, 2u64));
928 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
929 assert_eq!(result, MouseResult::Ignored);
930 }
931
932 #[test]
933 fn tabs_mouse_right_click_ignored() {
934 let mut state = TabsState::default();
935 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Right), 5, 0);
936 let hit = Some((HitId::new(1), HitRegion::Content, 2u64));
937 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
938 assert_eq!(result, MouseResult::Ignored);
939 }
940
941 #[test]
942 fn tabs_mouse_click_out_of_range() {
943 let mut state = TabsState::default();
944 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 0);
945 let hit = Some((HitId::new(1), HitRegion::Content, 20u64));
946 let result = state.handle_mouse(&event, hit, HitId::new(1), 5);
947 assert_eq!(result, MouseResult::Ignored);
948 }
949
950 #[test]
951 fn tabs_mouse_no_hit_ignored() {
952 let mut state = TabsState::default();
953 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 5, 0);
954 let result = state.handle_mouse(&event, None, HitId::new(1), 5);
955 assert_eq!(result, MouseResult::Ignored);
956 }
957
958 #[test]
961 fn tabs_close_active_empty_returns_none() {
962 let mut tabs = Tabs::new(Vec::<Tab>::new());
963 let mut state = TabsState::default();
964 assert!(tabs.close_active(&mut state).is_none());
965 }
966
967 #[test]
968 fn tabs_close_active_last_remaining_resets_state() {
969 let mut tabs = Tabs::new(vec![Tab::new("Only").closable(true)]);
970 let mut state = TabsState::default();
971 let removed = tabs.close_active(&mut state);
972 assert!(removed.is_some());
973 assert_eq!(removed.unwrap().title(), "Only");
974 assert!(tabs.tabs().is_empty());
975 assert_eq!(state.active, 0);
976 assert_eq!(state.offset, 0);
977 }
978
979 #[test]
980 fn tabs_close_active_middle_shifts_active() {
981 let mut tabs = Tabs::new(vec![
982 Tab::new("A"),
983 Tab::new("B").closable(true),
984 Tab::new("C"),
985 ]);
986 let mut state = TabsState::default();
987 state.select(1, 3); let removed = tabs.close_active(&mut state);
989 assert_eq!(removed.unwrap().title(), "B");
990 assert_eq!(tabs.tabs().len(), 2);
991 assert!(state.active < tabs.tabs().len());
993 }
994
995 #[test]
996 fn tabs_close_active_at_end_moves_active_back() {
997 let mut tabs = Tabs::new(vec![
998 Tab::new("A"),
999 Tab::new("B"),
1000 Tab::new("C").closable(true),
1001 ]);
1002 let mut state = TabsState::default();
1003 state.select(2, 3); tabs.close_active(&mut state);
1005 assert_eq!(tabs.tabs().len(), 2);
1006 assert_eq!(state.active, 1); }
1008
1009 #[test]
1012 fn tabs_move_active_left_at_boundary_returns_false() {
1013 let mut tabs = Tabs::new(vec![Tab::new("A"), Tab::new("B")]);
1014 let mut state = TabsState::default(); assert!(!tabs.move_active_left(&mut state));
1016 }
1017
1018 #[test]
1019 fn tabs_move_active_right_at_boundary_returns_false() {
1020 let mut tabs = Tabs::new(vec![Tab::new("A"), Tab::new("B")]);
1021 let mut state = TabsState::default();
1022 state.select(1, 2); assert!(!tabs.move_active_right(&mut state));
1024 }
1025
1026 #[test]
1027 fn tabs_move_active_single_tab_returns_false() {
1028 let mut tabs = Tabs::new(vec![Tab::new("Only")]);
1029 let mut state = TabsState::default();
1030 assert!(!tabs.move_active_left(&mut state));
1031 assert!(!tabs.move_active_right(&mut state));
1032 }
1033
1034 #[test]
1037 fn tabs_render_empty() {
1038 let tabs = Tabs::new(Vec::<Tab>::new());
1039 let mut state = TabsState::default();
1040 let mut pool = GraphemePool::new();
1041 let mut frame = Frame::new(20, 1, &mut pool);
1042 StatefulWidget::render(&tabs, Rect::new(0, 0, 20, 1), &mut frame, &mut state);
1043 let row = row_text(&frame, 0);
1045 assert_eq!(row.trim(), "");
1046 }
1047
1048 #[test]
1049 fn tabs_render_single_tab() {
1050 let tabs = Tabs::new(vec![Tab::new("Solo")]);
1051 let mut state = TabsState::default();
1052 let mut pool = GraphemePool::new();
1053 let mut frame = Frame::new(20, 1, &mut pool);
1054 StatefulWidget::render(&tabs, Rect::new(0, 0, 20, 1), &mut frame, &mut state);
1055 let row = row_text(&frame, 0);
1056 assert!(row.contains("[Solo]"));
1057 }
1058
1059 #[test]
1060 fn tabs_render_empty_clears_stale_row() {
1061 let populated = Tabs::new(vec![Tab::new("LongTab"), Tab::new("Other")]);
1062 let empty = Tabs::new(Vec::<Tab>::new());
1063 let mut state = TabsState::default();
1064 let mut pool = GraphemePool::new();
1065 let mut frame = Frame::new(20, 1, &mut pool);
1066
1067 StatefulWidget::render(&populated, Rect::new(0, 0, 20, 1), &mut frame, &mut state);
1068 assert_ne!(row_text(&frame, 0), " ".repeat(20));
1069
1070 StatefulWidget::render(&empty, Rect::new(0, 0, 20, 1), &mut frame, &mut state);
1071 assert_eq!(row_text(&frame, 0), " ".repeat(20));
1072 }
1073
1074 #[test]
1075 fn tabs_render_shorter_titles_clear_stale_suffix() {
1076 let long = Tabs::new(vec![Tab::new("LongTitle"), Tab::new("Second")]);
1077 let short = Tabs::new(vec![Tab::new("A"), Tab::new("B")]);
1078 let mut state = TabsState::default();
1079 let mut pool = GraphemePool::new();
1080 let mut frame = Frame::new(20, 1, &mut pool);
1081
1082 StatefulWidget::render(&long, Rect::new(0, 0, 20, 1), &mut frame, &mut state);
1083 StatefulWidget::render(&short, Rect::new(0, 0, 20, 1), &mut frame, &mut state);
1084
1085 assert_eq!(row_text(&frame, 0), "[A] B ");
1086 }
1087
1088 #[test]
1089 fn tabs_no_styling_drops_configured_styles() {
1090 let tabs = Tabs::new(vec![Tab::new("One").style(Style::new().italic())])
1091 .style(Style::new().bold())
1092 .active_style(Style::new().underline());
1093 let plain_tabs = Tabs::new(vec![Tab::new("One")]);
1094 let mut state = TabsState::default();
1095 let mut plain_state = TabsState::default();
1096 let mut pool = GraphemePool::new();
1097 let mut plain_pool = GraphemePool::new();
1098 let mut frame = Frame::new(10, 1, &mut pool);
1099 let mut plain_frame = Frame::new(10, 1, &mut plain_pool);
1100 frame.buffer.degradation = DegradationLevel::NoStyling;
1101 plain_frame.buffer.degradation = DegradationLevel::NoStyling;
1102
1103 StatefulWidget::render(&tabs, Rect::new(0, 0, 10, 1), &mut frame, &mut state);
1104 StatefulWidget::render(
1105 &plain_tabs,
1106 Rect::new(0, 0, 10, 1),
1107 &mut plain_frame,
1108 &mut plain_state,
1109 );
1110
1111 for x in 0..10 {
1112 let cell = frame.buffer.get(x, 0).expect("styled tab cell");
1113 let plain = plain_frame.buffer.get(x, 0).expect("plain tab cell");
1114 assert_eq!(cell, plain);
1115 }
1116 }
1117
1118 #[test]
1119 fn tabs_render_zero_area() {
1120 let tabs = Tabs::new(vec![Tab::new("A"), Tab::new("B")]);
1121 let mut state = TabsState::default();
1122 let mut pool = GraphemePool::new();
1123 let mut frame = Frame::new(20, 1, &mut pool);
1124 StatefulWidget::render(&tabs, Rect::new(0, 0, 0, 1), &mut frame, &mut state);
1126 }
1128
1129 #[test]
1130 fn tabs_render_closable_shows_marker() {
1131 let tabs = Tabs::new(vec![Tab::new("File").closable(true)]);
1132 let mut state = TabsState::default();
1133 let mut pool = GraphemePool::new();
1134 let mut frame = Frame::new(20, 1, &mut pool);
1135 StatefulWidget::render(&tabs, Rect::new(0, 0, 20, 1), &mut frame, &mut state);
1136 let row = row_text(&frame, 0);
1137 assert!(row.contains("x"), "closable tab should show close marker");
1138 }
1139
1140 #[test]
1141 fn tabs_render_active_tab_bracketed() {
1142 let tabs = Tabs::new(vec![Tab::new("A"), Tab::new("B"), Tab::new("C")]);
1143 let mut state = TabsState::default();
1144 state.select(1, 3);
1145 let mut pool = GraphemePool::new();
1146 let mut frame = Frame::new(30, 1, &mut pool);
1147 StatefulWidget::render(&tabs, Rect::new(0, 0, 30, 1), &mut frame, &mut state);
1148 let row = row_text(&frame, 0);
1149 assert!(row.contains("[B]"), "active tab should be bracketed");
1151 assert!(row.contains(" A "), "inactive tab A should be space-padded");
1152 assert!(row.contains(" C "), "inactive tab C should be space-padded");
1153 }
1154
1155 #[test]
1156 fn tabs_no_overflow_when_all_fit() {
1157 let tabs = Tabs::new(vec![Tab::new("A"), Tab::new("B")]);
1158 let mut state = TabsState::default();
1159 let mut pool = GraphemePool::new();
1160 let mut frame = Frame::new(30, 1, &mut pool);
1161 StatefulWidget::render(&tabs, Rect::new(0, 0, 30, 1), &mut frame, &mut state);
1162 let row = row_text(&frame, 0);
1163 assert!(!row.starts_with('<'), "no left overflow marker expected");
1165 assert!(!row.ends_with('>'), "no right overflow marker expected");
1166 }
1167
1168 #[test]
1171 fn tab_new_defaults() {
1172 let tab = Tab::new("test");
1173 assert_eq!(tab.title(), "test");
1174 assert!(!tab.is_closable());
1175 }
1176
1177 #[test]
1178 fn tab_closable_builder() {
1179 let tab = Tab::new("temp").closable(true);
1180 assert!(tab.is_closable());
1181 }
1182
1183 #[test]
1186 fn tabs_widget_stateless_render() {
1187 let tabs = Tabs::new(vec![Tab::new("X"), Tab::new("Y")]);
1188 let mut pool = GraphemePool::new();
1189 let mut frame = Frame::new(20, 1, &mut pool);
1190 Widget::render(&tabs, Rect::new(0, 0, 20, 1), &mut frame);
1191 let row = row_text(&frame, 0);
1192 assert!(row.contains("[X]"));
1194 }
1195
1196 #[test]
1199 fn tabs_overflow_both_sides() {
1200 let tabs = Tabs::new((0..10).map(|i| Tab::new(format!("Tab{i}"))));
1201 let mut state = TabsState::default();
1202 state.select(5, 10); let mut pool = GraphemePool::new();
1204 let mut frame = Frame::new(15, 1, &mut pool);
1205 StatefulWidget::render(&tabs, Rect::new(0, 0, 15, 1), &mut frame, &mut state);
1206 let row = row_text(&frame, 0);
1207 assert!(row.starts_with('<'), "expected left overflow marker");
1209 assert!(
1210 row.trim_end().ends_with('>'),
1211 "expected right overflow marker"
1212 );
1213 }
1214}