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