1#![forbid(unsafe_code)]
2
3use crate::mouse::MouseResult;
9use crate::{StatefulWidget, Widget, clear_text_row, draw_text_span};
10use ftui_core::event::{KeyCode, KeyEvent, KeyEventKind, MouseButton, MouseEvent, MouseEventKind};
11use ftui_core::geometry::Rect;
12use ftui_render::frame::{Frame, HitId, HitRegion};
13use ftui_style::Style;
14use ftui_text::display_width;
15#[cfg(feature = "tracing")]
16use web_time::Instant;
17
18#[derive(Debug, Clone, PartialEq, Eq)]
20pub struct Tab<'a> {
21 title: String,
22 style: Style,
23 closable: bool,
24 _marker: std::marker::PhantomData<&'a ()>,
25}
26
27impl<'a> Tab<'a> {
28 #[must_use]
30 pub fn new(title: impl Into<String>) -> Self {
31 Self {
32 title: title.into(),
33 style: Style::default(),
34 closable: false,
35 _marker: std::marker::PhantomData,
36 }
37 }
38
39 #[must_use]
41 pub fn style(mut self, style: Style) -> Self {
42 self.style = style;
43 self
44 }
45
46 #[must_use]
48 pub fn closable(mut self, closable: bool) -> Self {
49 self.closable = closable;
50 self
51 }
52
53 #[must_use]
55 pub fn title(&self) -> &str {
56 &self.title
57 }
58
59 #[must_use]
61 pub const fn is_closable(&self) -> bool {
62 self.closable
63 }
64}
65
66#[derive(Debug, Clone, Default, PartialEq, Eq)]
68pub struct TabsState {
69 pub active: usize,
71 pub offset: usize,
73}
74
75impl TabsState {
76 pub fn select(&mut self, index: usize, tab_count: usize) -> bool {
78 if tab_count == 0 {
79 self.active = 0;
80 self.offset = 0;
81 return false;
82 }
83 let next = index.min(tab_count.saturating_sub(1));
84 if self.active == next {
85 return false;
86 }
87 #[cfg(feature = "tracing")]
88 let old = self.active;
89 self.active = next;
90 if self.active < self.offset {
91 self.offset = self.active;
92 }
93 #[cfg(feature = "tracing")]
94 Self::log_switch("select", old, self.active);
95 true
96 }
97
98 pub fn next(&mut self, tab_count: usize) -> bool {
100 if tab_count == 0 {
101 return false;
102 }
103 self.select(
104 self.active
105 .saturating_add(1)
106 .min(tab_count.saturating_sub(1)),
107 tab_count,
108 )
109 }
110
111 pub fn previous(&mut self, tab_count: usize) -> bool {
113 if tab_count == 0 {
114 return false;
115 }
116 self.select(self.active.saturating_sub(1), tab_count)
117 }
118
119 pub fn handle_key(&mut self, key: &KeyEvent, tab_count: usize) -> bool {
129 if key.kind == KeyEventKind::Release {
130 return false;
131 }
132 match key.code {
133 KeyCode::Left => self.previous(tab_count),
134 KeyCode::Right => self.next(tab_count),
135 KeyCode::Char(ch) if ('1'..='9').contains(&ch) => {
136 let idx = ch as usize - '1' as usize;
137 if idx >= tab_count {
138 false
139 } else {
140 self.select(idx, tab_count)
141 }
142 }
143 _ => false,
144 }
145 }
146
147 pub fn handle_mouse(
151 &mut self,
152 event: &MouseEvent,
153 hit: Option<(HitId, HitRegion, u64)>,
154 expected_id: HitId,
155 tab_count: usize,
156 ) -> MouseResult {
157 match event.kind {
158 MouseEventKind::Down(MouseButton::Left) => {
159 if let Some((id, HitRegion::Content, data)) = hit
160 && id == expected_id
161 {
162 let idx = data as usize;
163 if idx < tab_count {
164 if self.active == idx {
165 return MouseResult::Activated(idx);
166 }
167 self.select(idx, tab_count);
168 return MouseResult::Selected(idx);
169 }
170 }
171 MouseResult::Ignored
172 }
173 _ => MouseResult::Ignored,
174 }
175 }
176
177 #[cfg(feature = "tracing")]
178 fn log_switch(reason: &str, from: usize, to: usize) {
179 tracing::debug!(message = "tabs.switch", reason, from, to);
180 }
181}
182
183#[derive(Debug, Clone, Default)]
185pub struct Tabs<'a> {
186 tabs: Vec<Tab<'a>>,
187 style: Style,
188 active_style: Style,
189 separator: &'a str,
190 close_marker: &'a str,
191 overflow_left_marker: &'a str,
192 overflow_right_marker: &'a str,
193 hit_id: Option<HitId>,
194}
195
196impl<'a> Tabs<'a> {
197 #[must_use]
199 pub fn new(tabs: impl IntoIterator<Item = Tab<'a>>) -> Self {
200 Self {
201 tabs: tabs.into_iter().collect(),
202 style: Style::default(),
203 active_style: Style::default(),
204 separator: " ",
205 close_marker: " x",
206 overflow_left_marker: "<",
207 overflow_right_marker: ">",
208 hit_id: None,
209 }
210 }
211
212 #[must_use]
214 pub fn style(mut self, style: Style) -> Self {
215 self.style = style;
216 self
217 }
218
219 #[must_use]
221 pub fn active_style(mut self, style: Style) -> Self {
222 self.active_style = style;
223 self
224 }
225
226 #[must_use]
228 pub fn separator(mut self, separator: &'a str) -> Self {
229 self.separator = separator;
230 self
231 }
232
233 #[must_use]
235 pub fn hit_id(mut self, id: HitId) -> Self {
236 self.hit_id = Some(id);
237 self
238 }
239
240 #[must_use]
242 pub fn tabs(&self) -> &[Tab<'a>] {
243 &self.tabs
244 }
245
246 fn tab_label_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 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 state.active >= end {
312 start = state.active;
313 state.offset = start;
314 end = self.visible_end(state, available_width);
315 }
316
317 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 end = self.visible_end(state, available_width);
337
338 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 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 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 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 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 #[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); }
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); }
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 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 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 #[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); let removed = tabs.close_active(&mut state);
985 assert_eq!(removed.unwrap().title(), "B");
986 assert_eq!(tabs.tabs().len(), 2);
987 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); tabs.close_active(&mut state);
1001 assert_eq!(tabs.tabs().len(), 2);
1002 assert_eq!(state.active, 1); }
1004
1005 #[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(); 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); 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 #[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 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 StatefulWidget::render(&tabs, Rect::new(0, 0, 0, 1), &mut frame, &mut state);
1122 }
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 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 assert!(!row.starts_with('<'), "no left overflow marker expected");
1161 assert!(!row.ends_with('>'), "no right overflow marker expected");
1162 }
1163
1164 #[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 #[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 assert!(row.contains("[X]"));
1190 }
1191
1192 #[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); 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 assert!(row.starts_with('<'), "expected left overflow marker");
1205 assert!(
1206 row.trim_end().ends_with('>'),
1207 "expected right overflow marker"
1208 );
1209 }
1210}