Skip to main content

ftui_widgets/
tabs.rs

1#![forbid(unsafe_code)]
2
3//! Tabs widget.
4//!
5//! Provides a horizontal tab bar with keyboard navigation, overflow handling,
6//! closable tabs, and tab reordering helpers.
7
8use 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/// A single tab entry.
19#[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    /// Create a new tab with a title.
29    #[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    /// Set style for this tab.
40    #[must_use]
41    pub fn style(mut self, style: Style) -> Self {
42        self.style = style;
43        self
44    }
45
46    /// Set whether this tab can be closed.
47    #[must_use]
48    pub fn closable(mut self, closable: bool) -> Self {
49        self.closable = closable;
50        self
51    }
52
53    /// Get tab title.
54    #[must_use]
55    pub fn title(&self) -> &str {
56        &self.title
57    }
58
59    /// Whether this tab can be closed.
60    #[must_use]
61    pub const fn is_closable(&self) -> bool {
62        self.closable
63    }
64}
65
66/// State for a [`Tabs`] widget.
67#[derive(Debug, Clone, Default, PartialEq, Eq)]
68pub struct TabsState {
69    /// Active tab index.
70    pub active: usize,
71    /// Left-most tab index when overflow scrolling is active.
72    pub offset: usize,
73}
74
75impl TabsState {
76    /// Select a specific tab index.
77    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    /// Move active tab right by one.
99    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    /// Move active tab left by one.
112    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    /// Handle keyboard tab switching.
120    ///
121    /// Supported:
122    /// - `Left` / `Right`
123    /// - number keys `1..9`
124    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    /// Handle mouse selection for tabs.
141    ///
142    /// Hit data convention: each tab row registers `data = tab_index as u64`.
143    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/// Tabs widget.
177#[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    /// Create tabs from an iterator.
191    #[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    /// Set base style.
206    #[must_use]
207    pub fn style(mut self, style: Style) -> Self {
208        self.style = style;
209        self
210    }
211
212    /// Set active tab style.
213    #[must_use]
214    pub fn active_style(mut self, style: Style) -> Self {
215        self.active_style = style;
216        self
217    }
218
219    /// Set separator between tabs.
220    #[must_use]
221    pub fn separator(mut self, separator: &'a str) -> Self {
222        self.separator = separator;
223        self
224    }
225
226    /// Set hit id for mouse interactions.
227    #[must_use]
228    pub fn hit_id(mut self, id: HitId) -> Self {
229        self.hit_id = Some(id);
230        self
231    }
232
233    /// Immutable tab slice.
234    #[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                // Always allow at least one tab; draw helper clips if too long.
274                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 active is out of view (e.g. initial render with small width), jump to it
315        if state.active >= end {
316            start = state.active;
317            state.offset = start;
318            end = self.visible_end(state, available_width);
319        }
320
321        // Iteratively refine width based on overflow markers
322        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            // Re-calculate with new width
340            end = self.visible_end(state, available_width);
341
342            // Ensure active is still visible
343            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    /// Close the active tab if it is closable.
356    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    /// Move active tab one position to the left.
378    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    /// Move active tab one position to the right.
389    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    // --- bd-1lg.28: Selection & switching tests ---
791
792    #[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); // clamped to last
815    }
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); // offset scrolled back to active
826    }
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        // 3 tabs: valid are '1','2','3'; '4' is out of range
867        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    // --- Mouse handling tests ---
879
880    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    // --- Close active tests ---
939
940    #[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); // select B
968        let removed = tabs.close_active(&mut state);
969        assert_eq!(removed.unwrap().title(), "B");
970        assert_eq!(tabs.tabs().len(), 2);
971        // Active should stay at 1 (now "C"), or adjust if at end
972        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); // select C (last)
984        tabs.close_active(&mut state);
985        assert_eq!(tabs.tabs().len(), 2);
986        assert_eq!(state.active, 1); // moved back to B
987    }
988
989    // --- Reorder tests ---
990
991    #[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(); // active = 0
995        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); // active = last
1003        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    // --- Render tests ---
1015
1016    #[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        // Should not panic; row should be blank
1024        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        // Zero width area
1105        StatefulWidget::render(&tabs, Rect::new(0, 0, 0, 1), &mut frame, &mut state);
1106        // Should not panic
1107    }
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        // Active tab B should be bracketed, A and C should not
1130        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        // Should not contain overflow markers
1144        assert!(!row.starts_with('<'), "no left overflow marker expected");
1145        assert!(!row.ends_with('>'), "no right overflow marker expected");
1146    }
1147
1148    // --- Tab struct tests ---
1149
1150    #[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    // --- Widget trait stateless render ---
1164
1165    #[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        // Default state: active=0, so X should be bracketed
1173        assert!(row.contains("[X]"));
1174    }
1175
1176    // --- Overflow visible range tests ---
1177
1178    #[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); // middle tab
1183        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        // Should show both overflow markers
1188        assert!(row.starts_with('<'), "expected left overflow marker");
1189        assert!(
1190            row.trim_end().ends_with('>'),
1191            "expected right overflow marker"
1192        );
1193    }
1194}