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