1#![forbid(unsafe_code)]
2
3use crate::mouse::MouseResult;
8use crate::{StatefulWidget, Widget, clear_text_area, draw_text_span};
9use ftui_core::event::{MouseButton, MouseEvent, MouseEventKind};
10use ftui_core::geometry::Rect;
11use ftui_render::frame::{Frame, HitId, HitRegion};
12use ftui_style::Style;
13use ftui_text::display_width;
14
15#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
17pub enum ScrollbarOrientation {
18 #[default]
20 VerticalRight,
21 VerticalLeft,
23 HorizontalBottom,
25 HorizontalTop,
27}
28
29pub const SCROLLBAR_PART_TRACK: u64 = 0;
31pub const SCROLLBAR_PART_THUMB: u64 = 1;
33pub const SCROLLBAR_PART_BEGIN: u64 = 2;
35pub const SCROLLBAR_PART_END: u64 = 3;
37
38#[derive(Debug, Clone, Default)]
40pub struct Scrollbar<'a> {
41 orientation: ScrollbarOrientation,
42 thumb_style: Style,
43 track_style: Style,
44 begin_symbol: Option<&'a str>,
45 end_symbol: Option<&'a str>,
46 track_symbol: Option<&'a str>,
47 thumb_symbol: Option<&'a str>,
48 hit_id: Option<HitId>,
49}
50
51impl<'a> Scrollbar<'a> {
52 #[must_use]
54 pub fn new(orientation: ScrollbarOrientation) -> Self {
55 Self {
56 orientation,
57 thumb_style: Style::default(),
58 track_style: Style::default(),
59 begin_symbol: None,
60 end_symbol: None,
61 track_symbol: None,
62 thumb_symbol: None,
63 hit_id: None,
64 }
65 }
66
67 #[must_use]
69 pub fn thumb_style(mut self, style: Style) -> Self {
70 self.thumb_style = style;
71 self
72 }
73
74 #[must_use]
76 pub fn track_style(mut self, style: Style) -> Self {
77 self.track_style = style;
78 self
79 }
80
81 #[must_use]
83 pub fn symbols(
84 mut self,
85 track: &'a str,
86 thumb: &'a str,
87 begin: Option<&'a str>,
88 end: Option<&'a str>,
89 ) -> Self {
90 self.track_symbol = Some(track);
91 self.thumb_symbol = Some(thumb);
92 self.begin_symbol = begin;
93 self.end_symbol = end;
94 self
95 }
96
97 #[must_use]
99 pub fn hit_id(mut self, id: HitId) -> Self {
100 self.hit_id = Some(id);
101 self
102 }
103}
104
105#[derive(Debug, Clone, Default)]
107pub struct ScrollbarState {
108 pub content_length: usize,
110 pub position: usize,
112 pub viewport_length: usize,
114 pub drag_anchor: Option<usize>,
116 track_layout: Option<TrackLayout>,
118}
119
120#[derive(Debug, Clone, Copy)]
121struct TrackLayout {
122 rect: Rect,
123 is_vertical: bool,
124}
125
126impl ScrollbarState {
127 #[must_use]
129 pub fn new(content_length: usize, position: usize, viewport_length: usize) -> Self {
130 Self {
131 content_length,
132 position,
133 viewport_length,
134 drag_anchor: None,
135 track_layout: None,
136 }
137 }
138
139 fn calc_thumb_geometry(&self, track_len: usize) -> (usize, usize) {
141 if track_len == 0 {
142 return (0, 0);
143 }
144 if self.content_length == 0 {
145 return (0, track_len);
146 }
147
148 let viewport_ratio = self.viewport_length as f64 / self.content_length as f64;
149 let thumb_size = (track_len as f64 * viewport_ratio).max(1.0).round() as usize;
150 let thumb_size = thumb_size.min(track_len);
151
152 let max_pos = self.content_length.saturating_sub(self.viewport_length);
153 let pos_ratio = if max_pos == 0 {
154 0.0
155 } else {
156 self.position.min(max_pos) as f64 / max_pos as f64
157 };
158
159 let available_track = track_len.saturating_sub(thumb_size);
160 let thumb_offset = (available_track as f64 * pos_ratio).round() as usize;
161
162 (thumb_offset, thumb_size)
163 }
164
165 pub fn handle_mouse(
182 &mut self,
183 event: &MouseEvent,
184 hit: Option<(HitId, HitRegion, u64)>,
185 expected_id: HitId,
186 ) -> MouseResult {
187 match event.kind {
188 MouseEventKind::Down(MouseButton::Left) => {
189 if let Some((id, HitRegion::Scrollbar, data)) = hit
190 && id == expected_id
191 {
192 let part = data >> 56;
193 match part {
194 SCROLLBAR_PART_BEGIN => {
195 self.scroll_up(1);
196 return MouseResult::Scrolled;
197 }
198 SCROLLBAR_PART_END => {
199 self.scroll_down(1);
200 return MouseResult::Scrolled;
201 }
202 SCROLLBAR_PART_THUMB => {
203 let track_len = ((data >> 28) & 0x0FFF_FFFF) as usize;
204 let track_pos = (data & 0x0FFF_FFFF) as usize;
205 let (thumb_offset, _) = self.calc_thumb_geometry(track_len);
206 self.drag_anchor = Some(track_pos.saturating_sub(thumb_offset));
208 return MouseResult::Scrolled;
210 }
211 SCROLLBAR_PART_TRACK => {
212 let track_len = ((data >> 28) & 0x0FFF_FFFF) as usize;
213 let track_pos = (data & 0x0FFF_FFFF) as usize;
214 if track_len == 0 {
215 return MouseResult::Ignored;
216 }
217
218 let (_, thumb_size) = self.calc_thumb_geometry(track_len);
220 let available = track_len.saturating_sub(thumb_size);
221 let denom = available.max(1);
222
223 let target_thumb_top = track_pos.saturating_sub(thumb_size / 2);
224 let clamped_top = target_thumb_top.min(denom);
225
226 let max_pos = self.content_length.saturating_sub(self.viewport_length);
227 self.position = if max_pos == 0 {
228 0
229 } else {
230 let num = (clamped_top as u128) * (max_pos as u128);
231 let pos = (num + (denom as u128 / 2)) / denom as u128;
232 pos as usize
233 };
234
235 let (thumb_offset, _) = self.calc_thumb_geometry(track_len);
238 self.drag_anchor = Some(track_pos.saturating_sub(thumb_offset));
239
240 return MouseResult::Scrolled;
241 }
242 _ => {}
243 }
244 }
245 MouseResult::Ignored
246 }
247 MouseEventKind::Drag(MouseButton::Left) => {
248 let hit_data = if let Some((id, HitRegion::Scrollbar, data)) = hit
252 && id == expected_id
253 {
254 let part = data >> 56;
255 if matches!(part, SCROLLBAR_PART_TRACK | SCROLLBAR_PART_THUMB) {
256 let len = ((data >> 28) & 0x0FFF_FFFF) as usize;
257 let pos = (data & 0x0FFF_FFFF) as usize;
258 Some((len, pos))
259 } else {
260 None
261 }
262 } else {
263 None
264 };
265
266 let (track_len, track_pos) = if let Some((len, pos)) = hit_data {
267 (len, pos)
268 } else if self.drag_anchor.is_some()
269 && let Some(layout) = self.track_layout
270 {
271 let rel = if layout.is_vertical {
273 event.y.saturating_sub(layout.rect.y)
274 } else {
275 event.x.saturating_sub(layout.rect.x)
276 };
277 let len = if layout.is_vertical {
278 layout.rect.height as usize
279 } else {
280 layout.rect.width as usize
281 };
282 let pos = rel.min(len.saturating_sub(1) as u16) as usize;
283 (len, pos)
284 } else {
285 return MouseResult::Ignored;
286 };
287
288 if track_len == 0 {
289 return MouseResult::Ignored;
290 }
291
292 let (_, thumb_size) = self.calc_thumb_geometry(track_len);
293 let available = track_len.saturating_sub(thumb_size);
294 let denom = available.max(1);
295
296 let anchor = self.drag_anchor.unwrap_or(thumb_size / 2);
299
300 let target_thumb_top = track_pos.saturating_sub(anchor);
302 let clamped_top = target_thumb_top.min(denom);
303
304 let max_pos = self.content_length.saturating_sub(self.viewport_length);
305 self.position = if max_pos == 0 {
306 0
307 } else {
308 let num = (clamped_top as u128) * (max_pos as u128);
310 let pos = (num + (denom as u128 / 2)) / denom as u128;
312 pos as usize
313 };
314 MouseResult::Scrolled
315 }
316 MouseEventKind::Up(MouseButton::Left) => {
317 let was_dragging = self.drag_anchor.take().is_some();
318 if was_dragging {
319 MouseResult::Scrolled
320 } else {
321 MouseResult::Ignored
322 }
323 }
324 MouseEventKind::ScrollUp => {
325 self.scroll_up(3);
326 MouseResult::Scrolled
327 }
328 MouseEventKind::ScrollDown => {
329 self.scroll_down(3);
330 MouseResult::Scrolled
331 }
332 _ => MouseResult::Ignored,
333 }
334 }
335
336 pub fn scroll_up(&mut self, lines: usize) {
338 self.position = self.position.saturating_sub(lines);
339 }
340
341 pub fn scroll_down(&mut self, lines: usize) {
345 let max_pos = self.content_length.saturating_sub(self.viewport_length);
346 self.position = self.position.saturating_add(lines).min(max_pos);
347 }
348}
349
350impl<'a> StatefulWidget for Scrollbar<'a> {
351 type State = ScrollbarState;
352
353 fn render(&self, area: Rect, frame: &mut Frame, state: &mut Self::State) {
354 if frame.a11y_enabled() && !area.is_empty() {
361 frame.push_a11y_nodes(ftui_a11y::Accessible::accessibility_nodes(self, area));
362 }
363 #[cfg(feature = "tracing")]
364 let _span = tracing::debug_span!(
365 "widget_render",
366 widget = "Scrollbar",
367 x = area.x,
368 y = area.y,
369 w = area.width,
370 h = area.height
371 )
372 .entered();
373
374 if !frame.should_render_widget(false) {
376 state.track_layout = None;
377 clear_text_area(frame, area, Style::default());
378 return;
379 }
380
381 if area.is_empty() || state.content_length == 0 {
382 state.track_layout = None;
383 clear_text_area(frame, area, Style::default());
384 return;
385 }
386
387 let is_vertical = match self.orientation {
388 ScrollbarOrientation::VerticalRight | ScrollbarOrientation::VerticalLeft => true,
389 ScrollbarOrientation::HorizontalBottom | ScrollbarOrientation::HorizontalTop => false,
390 };
391
392 let length = if is_vertical { area.height } else { area.width } as usize;
393 if length == 0 {
394 state.track_layout = None;
395 return;
396 }
397
398 let start_offset = if let Some(s) = self.begin_symbol {
400 if is_vertical { 1 } else { display_width(s) }
401 } else {
402 0
403 };
404 let end_offset = if let Some(s) = self.end_symbol {
405 if is_vertical { 1 } else { display_width(s) }
406 } else {
407 0
408 };
409
410 let track_len = length.saturating_sub(start_offset + end_offset);
412
413 let (thumb_offset, thumb_size) = state.calc_thumb_geometry(track_len);
415
416 let track_char = self
418 .track_symbol
419 .unwrap_or(if is_vertical { "│" } else { "─" });
420 let thumb_char = self.thumb_symbol.unwrap_or("█");
421 let begin_char = self
422 .begin_symbol
423 .unwrap_or(if is_vertical { "▲" } else { "◄" });
424 let end_char = self
425 .end_symbol
426 .unwrap_or(if is_vertical { "▼" } else { "►" });
427
428 let max_w = display_width(track_char)
430 .max(display_width(thumb_char))
431 .max(1);
432 let track_rect = if is_vertical {
433 let x = match self.orientation {
434 ScrollbarOrientation::VerticalRight => {
435 area.right().saturating_sub(max_w as u16).max(area.left())
436 }
437 ScrollbarOrientation::VerticalLeft => area.left(),
438 _ => unreachable!(),
439 };
440 Rect::new(
441 x,
442 area.top().saturating_add(start_offset as u16),
443 max_w as u16,
444 track_len as u16,
445 )
446 } else {
447 let y = match self.orientation {
448 ScrollbarOrientation::HorizontalBottom => area.bottom().saturating_sub(1),
449 ScrollbarOrientation::HorizontalTop => area.top(),
450 _ => unreachable!(),
451 };
452 Rect::new(
453 area.left().saturating_add(start_offset as u16),
454 y,
455 track_len as u16,
456 1,
457 )
458 };
459 state.track_layout = Some(TrackLayout {
460 rect: track_rect,
461 is_vertical,
462 });
463
464 let mut next_draw_index = 0;
466 for i in 0..length {
467 if i < next_draw_index {
468 continue;
469 }
470
471 let (symbol, part, rel_pos) = if i < start_offset {
473 (begin_char, SCROLLBAR_PART_BEGIN, 0)
474 } else if i >= length.saturating_sub(end_offset) {
475 (end_char, SCROLLBAR_PART_END, 0)
476 } else {
477 let track_idx = i - start_offset;
478 let is_thumb = track_idx >= thumb_offset && track_idx < thumb_offset + thumb_size;
479 if is_thumb {
480 (thumb_char, SCROLLBAR_PART_THUMB, track_idx)
481 } else {
482 (track_char, SCROLLBAR_PART_TRACK, track_idx)
483 }
484 };
485
486 let symbol_width = display_width(symbol);
487 if is_vertical {
488 next_draw_index = i + 1;
489 } else {
490 next_draw_index = i + symbol_width;
491 }
492
493 let style = if !frame.buffer.degradation.apply_styling() {
494 Style::default()
495 } else if part == SCROLLBAR_PART_THUMB {
496 self.thumb_style
497 } else {
498 self.track_style
499 };
500
501 let (x, y) = if is_vertical {
502 let x = match self.orientation {
503 ScrollbarOrientation::VerticalRight => area
504 .right()
505 .saturating_sub(symbol_width.max(1) as u16)
506 .max(area.left()),
507 ScrollbarOrientation::VerticalLeft => area.left(),
508 _ => unreachable!(),
509 };
510 (x, area.top().saturating_add(i as u16))
511 } else {
512 let y = match self.orientation {
513 ScrollbarOrientation::HorizontalBottom => area.bottom().saturating_sub(1),
514 ScrollbarOrientation::HorizontalTop => area.top(),
515 _ => unreachable!(),
516 };
517 (area.left().saturating_add(i as u16), y)
518 };
519
520 if x < area.right() && y < area.bottom() {
522 draw_text_span(frame, x, y, symbol, style, area.right());
523
524 if let Some(id) = self.hit_id {
525 let data = (part << 56)
527 | ((track_len as u64 & 0x0FFF_FFFF) << 28)
528 | (rel_pos as u64 & 0x0FFF_FFFF);
529
530 let hit_w = (symbol_width.max(1) as u16).min(area.right().saturating_sub(x));
531 frame.register_hit(Rect::new(x, y, hit_w, 1), id, HitRegion::Scrollbar, data);
532 }
533 }
534 }
535 }
536}
537
538impl<'a> Widget for Scrollbar<'a> {
539 fn render(&self, area: Rect, frame: &mut Frame) {
540 let mut state = ScrollbarState::default();
541 StatefulWidget::render(self, area, frame, &mut state);
542 }
543}
544
545impl ftui_a11y::Accessible for Scrollbar<'_> {
550 fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
551 use ftui_a11y::node::{A11yNodeInfo, A11yRole, A11yState};
552
553 let id = crate::a11y_node_id(area);
554 let orientation = match self.orientation {
555 ScrollbarOrientation::VerticalRight | ScrollbarOrientation::VerticalLeft => "vertical",
556 ScrollbarOrientation::HorizontalBottom | ScrollbarOrientation::HorizontalTop => {
557 "horizontal"
558 }
559 };
560 let name = format!("{orientation} scrollbar");
561 let node = A11yNodeInfo::new(id, A11yRole::ScrollBar, area)
562 .with_name(name)
563 .with_state(A11yState {
564 ..A11yState::default()
567 });
568 vec![node]
569 }
570}
571
572#[cfg(test)]
573mod tests {
574 use super::*;
575 use ftui_render::grapheme_pool::GraphemePool;
576
577 #[test]
578 fn scrollbar_empty_area() {
579 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
580 let area = Rect::new(0, 0, 0, 0);
581 let mut pool = GraphemePool::new();
582 let mut frame = Frame::new(1, 1, &mut pool);
583 let mut state = ScrollbarState::new(100, 0, 10);
584 StatefulWidget::render(&sb, area, &mut frame, &mut state);
585 }
586
587 #[test]
588 fn scrollbar_zero_content() {
589 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
590 let area = Rect::new(0, 0, 1, 10);
591 let mut pool = GraphemePool::new();
592 let mut frame = Frame::new(1, 10, &mut pool);
593 let mut state = ScrollbarState::new(100, 0, 10);
594 StatefulWidget::render(&sb, area, &mut frame, &mut state);
595
596 state.content_length = 0;
597 StatefulWidget::render(&sb, area, &mut frame, &mut state);
598
599 for y in 0..10u16 {
600 assert_eq!(frame.buffer.get(0, y).unwrap().content.as_char(), Some(' '));
601 }
602 assert!(state.track_layout.is_none());
603 }
604
605 #[test]
606 fn scrollbar_vertical_right_renders() {
607 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
608 let area = Rect::new(0, 0, 1, 10);
609 let mut pool = GraphemePool::new();
610 let mut frame = Frame::new(1, 10, &mut pool);
611 let mut state = ScrollbarState::new(100, 0, 10);
612 StatefulWidget::render(&sb, area, &mut frame, &mut state);
613
614 let top_cell = frame.buffer.get(0, 0).unwrap();
616 assert!(top_cell.content.as_char().is_some());
617 }
618
619 #[test]
620 fn scrollbar_vertical_left_renders() {
621 let sb = Scrollbar::new(ScrollbarOrientation::VerticalLeft);
622 let area = Rect::new(0, 0, 1, 10);
623 let mut pool = GraphemePool::new();
624 let mut frame = Frame::new(1, 10, &mut pool);
625 let mut state = ScrollbarState::new(100, 0, 10);
626 StatefulWidget::render(&sb, area, &mut frame, &mut state);
627
628 let top_cell = frame.buffer.get(0, 0).unwrap();
629 assert!(top_cell.content.as_char().is_some());
630 }
631
632 #[test]
633 fn scrollbar_horizontal_renders() {
634 let sb = Scrollbar::new(ScrollbarOrientation::HorizontalBottom);
635 let area = Rect::new(0, 0, 10, 1);
636 let mut pool = GraphemePool::new();
637 let mut frame = Frame::new(10, 1, &mut pool);
638 let mut state = ScrollbarState::new(100, 0, 10);
639 StatefulWidget::render(&sb, area, &mut frame, &mut state);
640
641 let left_cell = frame.buffer.get(0, 0).unwrap();
642 assert!(left_cell.content.as_char().is_some());
643 }
644
645 #[test]
646 fn scrollbar_thumb_moves_with_position() {
647 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
648 let area = Rect::new(0, 0, 1, 10);
649
650 let mut pool1 = GraphemePool::new();
652 let mut frame1 = Frame::new(1, 10, &mut pool1);
653 let mut state1 = ScrollbarState::new(100, 0, 10);
654 StatefulWidget::render(&sb, area, &mut frame1, &mut state1);
655
656 let mut pool2 = GraphemePool::new();
658 let mut frame2 = Frame::new(1, 10, &mut pool2);
659 let mut state2 = ScrollbarState::new(100, 90, 10);
660 StatefulWidget::render(&sb, area, &mut frame2, &mut state2);
661
662 let thumb_char = '█';
664 let thumb_pos_1 = (0..10u16)
665 .find(|&y| frame1.buffer.get(0, y).unwrap().content.as_char() == Some(thumb_char));
666 let thumb_pos_2 = (0..10u16)
667 .find(|&y| frame2.buffer.get(0, y).unwrap().content.as_char() == Some(thumb_char));
668
669 assert!(thumb_pos_1.unwrap_or(0) < thumb_pos_2.unwrap_or(0));
671 }
672
673 #[test]
674 fn scrollbar_state_constructor() {
675 let state = ScrollbarState::new(200, 50, 20);
676 assert_eq!(state.content_length, 200);
677 assert_eq!(state.position, 50);
678 assert_eq!(state.viewport_length, 20);
679 }
680
681 #[test]
682 fn scrollbar_content_fits_viewport() {
683 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
685 let area = Rect::new(0, 0, 1, 10);
686 let mut pool = GraphemePool::new();
687 let mut frame = Frame::new(1, 10, &mut pool);
688 let mut state = ScrollbarState::new(5, 0, 10);
689 StatefulWidget::render(&sb, area, &mut frame, &mut state);
690
691 let thumb_char = '█';
693 for y in 0..10u16 {
694 assert_eq!(
695 frame.buffer.get(0, y).unwrap().content.as_char(),
696 Some(thumb_char)
697 );
698 }
699 }
700
701 #[test]
702 fn scrollbar_horizontal_top_renders() {
703 let sb = Scrollbar::new(ScrollbarOrientation::HorizontalTop);
704 let area = Rect::new(0, 0, 10, 1);
705 let mut pool = GraphemePool::new();
706 let mut frame = Frame::new(10, 1, &mut pool);
707 let mut state = ScrollbarState::new(100, 0, 10);
708 StatefulWidget::render(&sb, area, &mut frame, &mut state);
709
710 let left_cell = frame.buffer.get(0, 0).unwrap();
711 assert!(left_cell.content.as_char().is_some());
712 }
713
714 #[test]
715 fn scrollbar_custom_symbols() {
716 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight).symbols(
717 ".",
718 "#",
719 Some("^"),
720 Some("v"),
721 );
722 let area = Rect::new(0, 0, 1, 5);
723 let mut pool = GraphemePool::new();
724 let mut frame = Frame::new(1, 5, &mut pool);
725 let mut state = ScrollbarState::new(50, 0, 10);
726 StatefulWidget::render(&sb, area, &mut frame, &mut state);
727
728 let mut chars: Vec<Option<char>> = Vec::new();
730 for y in 0..5u16 {
731 chars.push(frame.buffer.get(0, y).unwrap().content.as_char());
732 }
733 assert!(chars.contains(&Some('#')) || chars.contains(&Some('.')));
735 }
736
737 #[test]
738 fn scrollbar_position_clamped_beyond_max() {
739 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
740 let area = Rect::new(0, 0, 1, 10);
741 let mut pool = GraphemePool::new();
742 let mut frame = Frame::new(1, 10, &mut pool);
743 let mut state = ScrollbarState::new(100, 500, 10);
745 StatefulWidget::render(&sb, area, &mut frame, &mut state);
746
747 let thumb_char = '█';
749 let thumb_pos = (0..10u16)
750 .find(|&y| frame.buffer.get(0, y).unwrap().content.as_char() == Some(thumb_char));
751 assert!(thumb_pos.is_some());
752 }
753
754 #[test]
755 fn scrollbar_state_default() {
756 let state = ScrollbarState::default();
757 assert_eq!(state.content_length, 0);
758 assert_eq!(state.position, 0);
759 assert_eq!(state.viewport_length, 0);
760 }
761
762 #[test]
763 fn scrollbar_widget_trait_renders() {
764 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
765 let area = Rect::new(0, 0, 1, 5);
766 let mut pool = GraphemePool::new();
767 let mut frame = Frame::new(1, 5, &mut pool);
768 Widget::render(&sb, area, &mut frame);
770 }
772
773 #[test]
774 fn scrollbar_orientation_default_is_vertical_right() {
775 assert_eq!(
776 ScrollbarOrientation::default(),
777 ScrollbarOrientation::VerticalRight
778 );
779 }
780
781 #[test]
784 fn degradation_essential_only_skips_entirely() {
785 use ftui_render::budget::DegradationLevel;
786
787 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
788 let area = Rect::new(0, 0, 1, 10);
789 let mut pool = GraphemePool::new();
790 let mut frame = Frame::new(1, 10, &mut pool);
791 frame.buffer.degradation = DegradationLevel::EssentialOnly;
792 let mut state = ScrollbarState::new(100, 0, 10);
793 frame.buffer.degradation = DegradationLevel::Full;
794 StatefulWidget::render(&sb, area, &mut frame, &mut state);
795 frame.buffer.degradation = DegradationLevel::EssentialOnly;
796 StatefulWidget::render(&sb, area, &mut frame, &mut state);
797
798 for y in 0..10u16 {
799 assert_eq!(frame.buffer.get(0, y).unwrap().content.as_char(), Some(' '));
800 }
801 assert!(state.track_layout.is_none());
802 }
803
804 #[test]
805 fn degradation_skeleton_skips_entirely() {
806 use ftui_render::budget::DegradationLevel;
807
808 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
809 let area = Rect::new(0, 0, 1, 10);
810 let mut pool = GraphemePool::new();
811 let mut frame = Frame::new(1, 10, &mut pool);
812 frame.buffer.degradation = DegradationLevel::Skeleton;
813 let mut state = ScrollbarState::new(100, 0, 10);
814 frame.buffer.degradation = DegradationLevel::Full;
815 StatefulWidget::render(&sb, area, &mut frame, &mut state);
816 frame.buffer.degradation = DegradationLevel::Skeleton;
817 StatefulWidget::render(&sb, area, &mut frame, &mut state);
818
819 for y in 0..10u16 {
820 assert_eq!(frame.buffer.get(0, y).unwrap().content.as_char(), Some(' '));
821 }
822 assert!(state.track_layout.is_none());
823 }
824
825 #[test]
826 fn degradation_full_renders_scrollbar() {
827 use ftui_render::budget::DegradationLevel;
828
829 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
830 let area = Rect::new(0, 0, 1, 10);
831 let mut pool = GraphemePool::new();
832 let mut frame = Frame::new(1, 10, &mut pool);
833 frame.buffer.degradation = DegradationLevel::Full;
834 let mut state = ScrollbarState::new(100, 0, 10);
835 StatefulWidget::render(&sb, area, &mut frame, &mut state);
836
837 let top_cell = frame.buffer.get(0, 0).unwrap();
839 assert!(top_cell.content.as_char().is_some());
840 }
841
842 #[test]
843 fn degradation_simple_borders_still_renders() {
844 use ftui_render::budget::DegradationLevel;
845
846 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight);
847 let area = Rect::new(0, 0, 1, 10);
848 let mut pool = GraphemePool::new();
849 let mut frame = Frame::new(1, 10, &mut pool);
850 frame.buffer.degradation = DegradationLevel::SimpleBorders;
851 let mut state = ScrollbarState::new(100, 0, 10);
852 StatefulWidget::render(&sb, area, &mut frame, &mut state);
853
854 let top_cell = frame.buffer.get(0, 0).unwrap();
856 assert!(top_cell.content.as_char().is_some());
857 }
858
859 #[test]
860 fn scrollbar_wide_symbols_horizontal() {
861 let sb =
862 Scrollbar::new(ScrollbarOrientation::HorizontalBottom).symbols("🔴", "👍", None, None);
863 let area = Rect::new(0, 0, 4, 1);
865 let mut pool = GraphemePool::new();
866 let mut frame = Frame::new(4, 1, &mut pool);
867 let mut state = ScrollbarState::new(10, 0, 10);
872
873 StatefulWidget::render(&sb, area, &mut frame, &mut state);
874
875 let c0 = frame.buffer.get(0, 0).unwrap();
877 assert!(!c0.is_empty() && !c0.is_continuation()); let c1 = frame.buffer.get(1, 0).unwrap();
880 assert!(c1.is_continuation());
881
882 let c2 = frame.buffer.get(2, 0).unwrap();
884 assert!(!c2.is_empty() && !c2.is_continuation()); let c3 = frame.buffer.get(3, 0).unwrap();
887 assert!(c3.is_continuation());
888 }
889
890 #[test]
891 fn scrollbar_wide_symbols_vertical() {
892 let sb =
893 Scrollbar::new(ScrollbarOrientation::VerticalRight).symbols("🔴", "👍", None, None);
894 let area = Rect::new(0, 0, 2, 2);
896 let mut pool = GraphemePool::new();
897 let mut frame = Frame::new(2, 2, &mut pool);
898 let mut state = ScrollbarState::new(10, 0, 10); StatefulWidget::render(&sb, area, &mut frame, &mut state);
901
902 let r0_c0 = frame.buffer.get(0, 0).unwrap();
904 assert!(!r0_c0.is_empty() && !r0_c0.is_continuation()); let r0_c1 = frame.buffer.get(1, 0).unwrap();
906 assert!(r0_c1.is_continuation()); let r1_c0 = frame.buffer.get(0, 1).unwrap();
910 assert!(!r1_c0.is_empty() && !r1_c0.is_continuation()); let r1_c1 = frame.buffer.get(1, 1).unwrap();
912 assert!(r1_c1.is_continuation()); }
914
915 #[test]
916 fn scrollbar_wide_symbol_clips_drawing_and_hits_to_area() {
917 let sb = Scrollbar::new(ScrollbarOrientation::HorizontalBottom)
919 .symbols("🔴", "👍", None, None)
920 .hit_id(HitId::new(1));
921 let area = Rect::new(0, 0, 3, 1);
922 let mut pool = GraphemePool::new();
923 let mut frame = Frame::with_hit_grid(5, 1, &mut pool);
924 let mut state = ScrollbarState::new(3, 0, 3); StatefulWidget::render(&sb, area, &mut frame, &mut state);
927
928 let outside = frame.buffer.get(3, 0).unwrap();
930 assert!(outside.is_empty(), "cell outside area should remain empty");
931 assert!(frame.hit_test(3, 0).is_none(), "no hit outside area");
932 }
933
934 #[test]
935 fn scrollbar_wide_symbol_vertical_clips_drawing_and_hits_to_area() {
936 let sb = Scrollbar::new(ScrollbarOrientation::VerticalLeft)
937 .symbols("🔴", "👍", None, None)
938 .hit_id(HitId::new(1));
939 let area = Rect::new(0, 0, 1, 2);
940 let mut pool = GraphemePool::new();
941 let mut frame = Frame::with_hit_grid(2, 2, &mut pool);
942 let mut state = ScrollbarState::new(10, 0, 10); StatefulWidget::render(&sb, area, &mut frame, &mut state);
945
946 let outside = frame.buffer.get(1, 0).unwrap();
948 assert!(outside.is_empty(), "cell outside area should remain empty");
949 assert!(frame.hit_test(1, 0).is_none(), "no hit outside area");
950 }
951
952 #[test]
953 fn scrollbar_vertical_right_never_draws_left_of_area_for_wide_symbols() {
954 let sb = Scrollbar::new(ScrollbarOrientation::VerticalRight)
957 .symbols("🔴", "👍", None, None)
958 .hit_id(HitId::new(1));
959 let area = Rect::new(2, 0, 1, 2);
960 let mut pool = GraphemePool::new();
961 let mut frame = Frame::with_hit_grid(4, 2, &mut pool);
962 let mut state = ScrollbarState::new(10, 0, 10);
963
964 StatefulWidget::render(&sb, area, &mut frame, &mut state);
965
966 let outside = frame.buffer.get(1, 0).unwrap();
968 assert!(outside.is_empty(), "cell left of area should remain empty");
969 assert!(frame.hit_test(1, 0).is_none(), "no hit left of area");
970 }
971
972 use crate::mouse::MouseResult;
975 use ftui_core::event::{MouseButton, MouseEvent, MouseEventKind};
976
977 #[test]
978 fn scrollbar_state_begin_button() {
979 let mut state = ScrollbarState::new(100, 10, 20);
980 let data = SCROLLBAR_PART_BEGIN << 56;
981 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
982 let hit = Some((HitId::new(1), HitRegion::Scrollbar, data));
983 let result = state.handle_mouse(&event, hit, HitId::new(1));
984 assert_eq!(result, MouseResult::Scrolled);
985 assert_eq!(state.position, 9);
986 }
987
988 #[test]
989 fn scrollbar_state_end_button() {
990 let mut state = ScrollbarState::new(100, 10, 20);
991 let data = SCROLLBAR_PART_END << 56;
992 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
993 let hit = Some((HitId::new(1), HitRegion::Scrollbar, data));
994 let result = state.handle_mouse(&event, hit, HitId::new(1));
995 assert_eq!(result, MouseResult::Scrolled);
996 assert_eq!(state.position, 11);
997 }
998
999 #[test]
1000 fn scrollbar_state_track_click() {
1001 let mut state = ScrollbarState::new(100, 0, 20);
1002 let track_len = 20u64;
1003 let track_pos = 10u64;
1004 let data = (SCROLLBAR_PART_TRACK << 56)
1005 | ((track_len & 0x0FFF_FFFF) << 28)
1006 | (track_pos & 0x0FFF_FFFF);
1007 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
1008 let hit = Some((HitId::new(1), HitRegion::Scrollbar, data));
1009 let result = state.handle_mouse(&event, hit, HitId::new(1));
1010 assert_eq!(result, MouseResult::Scrolled);
1011 assert_eq!(state.position, 40);
1013 }
1014
1015 #[test]
1016 fn scrollbar_state_track_click_clamps() {
1017 let mut state = ScrollbarState::new(100, 0, 20);
1018 let track_len = 20u64;
1019 let track_pos = 95u64;
1020 let data = (SCROLLBAR_PART_TRACK << 56)
1021 | ((track_len & 0x0FFF_FFFF) << 28)
1022 | (track_pos & 0x0FFF_FFFF);
1023 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
1024 let hit = Some((HitId::new(1), HitRegion::Scrollbar, data));
1025 let result = state.handle_mouse(&event, hit, HitId::new(1));
1026 assert_eq!(result, MouseResult::Scrolled);
1027 assert_eq!(state.position, 80); }
1029
1030 #[test]
1031 fn scrollbar_state_thumb_drag_updates_position() {
1032 let mut state = ScrollbarState::new(100, 0, 20);
1033 let track_len = 20u64;
1034 let track_pos = 19u64;
1035 let data = (SCROLLBAR_PART_THUMB << 56)
1036 | ((track_len & 0x0FFF_FFFF) << 28)
1037 | (track_pos & 0x0FFF_FFFF);
1038 let event = MouseEvent::new(MouseEventKind::Drag(MouseButton::Left), 0, 0);
1039 let hit = Some((HitId::new(1), HitRegion::Scrollbar, data));
1040 let result = state.handle_mouse(&event, hit, HitId::new(1));
1041 assert_eq!(result, MouseResult::Scrolled);
1042 assert_eq!(state.position, 80);
1043 }
1044
1045 #[test]
1046 fn scrollbar_state_scroll_wheel_up() {
1047 let mut state = ScrollbarState::new(100, 10, 20);
1048 let event = MouseEvent::new(MouseEventKind::ScrollUp, 0, 0);
1049 let result = state.handle_mouse(&event, None, HitId::new(1));
1050 assert_eq!(result, MouseResult::Scrolled);
1051 assert_eq!(state.position, 7);
1052 }
1053
1054 #[test]
1055 fn scrollbar_state_scroll_wheel_down() {
1056 let mut state = ScrollbarState::new(100, 10, 20);
1057 let event = MouseEvent::new(MouseEventKind::ScrollDown, 0, 0);
1058 let result = state.handle_mouse(&event, None, HitId::new(1));
1059 assert_eq!(result, MouseResult::Scrolled);
1060 assert_eq!(state.position, 13);
1061 }
1062
1063 #[test]
1064 fn scrollbar_state_scroll_down_clamps() {
1065 let mut state = ScrollbarState::new(100, 78, 20);
1066 state.scroll_down(5);
1067 assert_eq!(state.position, 80); }
1069
1070 #[test]
1071 fn scrollbar_state_scroll_up_clamps() {
1072 let mut state = ScrollbarState::new(100, 2, 20);
1073 state.scroll_up(5);
1074 assert_eq!(state.position, 0);
1075 }
1076
1077 #[test]
1078 fn scrollbar_state_wrong_id_ignored() {
1079 let mut state = ScrollbarState::new(100, 10, 20);
1080 let data = SCROLLBAR_PART_BEGIN << 56;
1081 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Left), 0, 0);
1082 let hit = Some((HitId::new(99), HitRegion::Scrollbar, data));
1083 let result = state.handle_mouse(&event, hit, HitId::new(1));
1084 assert_eq!(result, MouseResult::Ignored);
1085 assert_eq!(state.position, 10);
1086 }
1087
1088 #[test]
1089 fn scrollbar_state_right_click_ignored() {
1090 let mut state = ScrollbarState::new(100, 10, 20);
1091 let event = MouseEvent::new(MouseEventKind::Down(MouseButton::Right), 0, 0);
1092 let result = state.handle_mouse(&event, None, HitId::new(1));
1093 assert_eq!(result, MouseResult::Ignored);
1094 }
1095}