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, 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/// 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    ///
125    /// Acts on press and repeat, never release. Terminals with the kitty
126    /// keyboard protocol's event types, and the web backend, report a release
127    /// for every key, so one Right press moved two tabs.
128    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    /// Handle mouse selection for tabs.
148    ///
149    /// Hit data convention: each tab row registers `data = tab_index as u64`.
150    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/// Tabs widget.
184#[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    /// Create tabs from an iterator.
198    #[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    /// Set base style.
213    #[must_use]
214    pub fn style(mut self, style: Style) -> Self {
215        self.style = style;
216        self
217    }
218
219    /// Set active tab style.
220    #[must_use]
221    pub fn active_style(mut self, style: Style) -> Self {
222        self.active_style = style;
223        self
224    }
225
226    /// Set separator between tabs.
227    #[must_use]
228    pub fn separator(mut self, separator: &'a str) -> Self {
229        self.separator = separator;
230        self
231    }
232
233    /// Set hit id for mouse interactions.
234    #[must_use]
235    pub fn hit_id(mut self, id: HitId) -> Self {
236        self.hit_id = Some(id);
237        self
238    }
239
240    /// Immutable tab slice.
241    #[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                // Always allow at least one tab; draw helper clips if too long.
281                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 active is out of view (e.g. initial render with small width), jump to it
322        if state.active >= end {
323            start = state.active;
324            state.offset = start;
325            end = self.visible_end(state, available_width);
326        }
327
328        // Iteratively refine width based on overflow markers
329        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            // Re-calculate with new width
347            end = self.visible_end(state, available_width);
348
349            // Ensure active is still visible
350            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    /// Close the active tab if it is closable.
363    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    /// Move active tab one position to the left.
385    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    /// Move active tab one position to the right.
396    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        // With release events reported, one Right press moved two tabs.
609        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    // --- bd-1lg.28: Selection & switching tests ---
811
812    #[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); // clamped to last
835    }
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); // offset scrolled back to active
846    }
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        // 3 tabs: valid are '1','2','3'; '4' is out of range
887        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    // --- Mouse handling tests ---
899
900    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    // --- Close active tests ---
959
960    #[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); // select B
988        let removed = tabs.close_active(&mut state);
989        assert_eq!(removed.unwrap().title(), "B");
990        assert_eq!(tabs.tabs().len(), 2);
991        // Active should stay at 1 (now "C"), or adjust if at end
992        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); // select C (last)
1004        tabs.close_active(&mut state);
1005        assert_eq!(tabs.tabs().len(), 2);
1006        assert_eq!(state.active, 1); // moved back to B
1007    }
1008
1009    // --- Reorder tests ---
1010
1011    #[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(); // active = 0
1015        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); // active = last
1023        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    // --- Render tests ---
1035
1036    #[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        // Should not panic; row should be blank
1044        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        // Zero width area
1125        StatefulWidget::render(&tabs, Rect::new(0, 0, 0, 1), &mut frame, &mut state);
1126        // Should not panic
1127    }
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        // Active tab B should be bracketed, A and C should not
1150        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        // Should not contain overflow markers
1164        assert!(!row.starts_with('<'), "no left overflow marker expected");
1165        assert!(!row.ends_with('>'), "no right overflow marker expected");
1166    }
1167
1168    // --- Tab struct tests ---
1169
1170    #[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    // --- Widget trait stateless render ---
1184
1185    #[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        // Default state: active=0, so X should be bracketed
1193        assert!(row.contains("[X]"));
1194    }
1195
1196    // --- Overflow visible range tests ---
1197
1198    #[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); // middle tab
1203        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        // Should show both overflow markers
1208        assert!(row.starts_with('<'), "expected left overflow marker");
1209        assert!(
1210            row.trim_end().ends_with('>'),
1211            "expected right overflow marker"
1212        );
1213    }
1214}