1#![forbid(unsafe_code)]
2
3use crate::Widget;
4use crate::borders::{BorderSet, BorderType, Borders};
5use crate::measurable::{MeasurableWidget, SizeConstraints};
6use crate::{apply_style, draw_text_span, set_style_area};
7use ftui_core::geometry::{Rect, Sides, Size};
8use ftui_render::buffer::Buffer;
9use ftui_render::cell::Cell;
10use ftui_render::frame::Frame;
11use ftui_style::Style;
12use ftui_text::{grapheme_width, graphemes};
13
14#[derive(Debug, Clone, PartialEq, Eq, Default)]
16pub struct Block<'a> {
17 borders: Borders,
18 border_style: Style,
19 border_type: BorderType,
20 title: Option<&'a str>,
21 title_alignment: Alignment,
22 style: Style,
23 padding: Sides,
24}
25
26#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
28pub enum Alignment {
29 #[default]
30 Left,
32 Center,
34 Right,
36}
37
38impl<'a> Block<'a> {
39 #[must_use]
41 pub fn new() -> Self {
42 Self::default()
43 }
44
45 #[must_use]
47 pub fn bordered() -> Self {
48 Self::default().borders(Borders::ALL).padding(Sides::all(1))
49 }
50
51 #[must_use]
53 pub fn borders(mut self, borders: Borders) -> Self {
54 self.borders = borders;
55 self
56 }
57
58 #[must_use]
60 pub fn border_style(mut self, style: Style) -> Self {
61 self.border_style = style;
62 self
63 }
64
65 #[must_use]
67 pub fn border_type(mut self, border_type: BorderType) -> Self {
68 self.border_type = border_type;
69 self
70 }
71
72 #[must_use]
74 pub fn padding(mut self, padding: impl Into<Sides>) -> Self {
75 self.padding = padding.into();
76 self
77 }
78
79 pub(crate) fn border_set(&self) -> BorderSet {
81 self.border_type.to_border_set()
82 }
83
84 #[must_use]
86 pub fn title(mut self, title: &'a str) -> Self {
87 self.title = Some(title);
88 self
89 }
90
91 #[must_use]
93 pub fn title_text(&self) -> Option<&str> {
94 self.title
95 }
96
97 #[must_use]
99 pub fn title_alignment(mut self, alignment: Alignment) -> Self {
100 self.title_alignment = alignment;
101 self
102 }
103
104 #[must_use]
106 pub fn style(mut self, style: Style) -> Self {
107 self.style = style;
108 self
109 }
110
111 #[must_use]
113 pub fn inner(&self, area: Rect) -> Rect {
114 let mut inner = area;
115
116 if self.borders.contains(Borders::LEFT) {
117 inner.x = inner.x.saturating_add(1);
118 inner.width = inner.width.saturating_sub(1);
119 }
120 if self.borders.contains(Borders::TOP) {
121 inner.y = inner.y.saturating_add(1);
122 inner.height = inner.height.saturating_sub(1);
123 }
124 if self.borders.contains(Borders::RIGHT) {
125 inner.width = inner.width.saturating_sub(1);
126 }
127 if self.borders.contains(Borders::BOTTOM) {
128 inner.height = inner.height.saturating_sub(1);
129 }
130
131 inner.inner(self.padding)
132 }
133
134 #[must_use]
139 pub fn chrome_size(&self) -> (u16, u16) {
140 let border_h = self.borders.contains(Borders::LEFT) as u16
141 + self.borders.contains(Borders::RIGHT) as u16;
142 let border_v = self.borders.contains(Borders::TOP) as u16
143 + self.borders.contains(Borders::BOTTOM) as u16;
144
145 let padding_h = self.padding.left + self.padding.right;
146 let padding_v = self.padding.top + self.padding.bottom;
147
148 (
149 border_h.saturating_add(padding_h),
150 border_v.saturating_add(padding_v),
151 )
152 }
153
154 fn border_cell(&self, c: char, style: Style) -> Cell {
156 let mut cell = Cell::from_char(c);
157 apply_style(&mut cell, style);
158 cell
159 }
160
161 fn render_borders(&self, area: Rect, buf: &mut Buffer, style: Style) {
162 if area.is_empty() {
163 return;
164 }
165
166 let set = self.border_set();
167
168 if self.borders.contains(Borders::LEFT) {
170 for y in area.y..area.bottom() {
171 buf.set_fast(area.x, y, self.border_cell(set.vertical, style));
172 }
173 }
174 if self.borders.contains(Borders::RIGHT) {
175 let x = area.right() - 1;
176 for y in area.y..area.bottom() {
177 buf.set_fast(x, y, self.border_cell(set.vertical, style));
178 }
179 }
180 if self.borders.contains(Borders::TOP) {
181 for x in area.x..area.right() {
182 buf.set_fast(x, area.y, self.border_cell(set.horizontal, style));
183 }
184 }
185 if self.borders.contains(Borders::BOTTOM) {
186 let y = area.bottom() - 1;
187 for x in area.x..area.right() {
188 buf.set_fast(x, y, self.border_cell(set.horizontal, style));
189 }
190 }
191
192 if self.borders.contains(Borders::LEFT | Borders::TOP) {
194 buf.set_fast(area.x, area.y, self.border_cell(set.top_left, style));
195 }
196 if self.borders.contains(Borders::RIGHT | Borders::TOP) {
197 buf.set_fast(
198 area.right() - 1,
199 area.y,
200 self.border_cell(set.top_right, style),
201 );
202 }
203 if self.borders.contains(Borders::LEFT | Borders::BOTTOM) {
204 buf.set_fast(
205 area.x,
206 area.bottom() - 1,
207 self.border_cell(set.bottom_left, style),
208 );
209 }
210 if self.borders.contains(Borders::RIGHT | Borders::BOTTOM) {
211 buf.set_fast(
212 area.right() - 1,
213 area.bottom() - 1,
214 self.border_cell(set.bottom_right, style),
215 );
216 }
217 }
218
219 fn render_borders_ascii(&self, area: Rect, buf: &mut Buffer, style: Style) {
221 if area.is_empty() {
222 return;
223 }
224
225 let set = crate::borders::BorderSet::ASCII;
226
227 if self.borders.contains(Borders::LEFT) {
228 for y in area.y..area.bottom() {
229 buf.set_fast(area.x, y, self.border_cell(set.vertical, style));
230 }
231 }
232 if self.borders.contains(Borders::RIGHT) {
233 let x = area.right() - 1;
234 for y in area.y..area.bottom() {
235 buf.set_fast(x, y, self.border_cell(set.vertical, style));
236 }
237 }
238 if self.borders.contains(Borders::TOP) {
239 for x in area.x..area.right() {
240 buf.set_fast(x, area.y, self.border_cell(set.horizontal, style));
241 }
242 }
243 if self.borders.contains(Borders::BOTTOM) {
244 let y = area.bottom() - 1;
245 for x in area.x..area.right() {
246 buf.set_fast(x, y, self.border_cell(set.horizontal, style));
247 }
248 }
249
250 if self.borders.contains(Borders::LEFT | Borders::TOP) {
251 buf.set_fast(area.x, area.y, self.border_cell(set.top_left, style));
252 }
253 if self.borders.contains(Borders::RIGHT | Borders::TOP) {
254 buf.set_fast(
255 area.right() - 1,
256 area.y,
257 self.border_cell(set.top_right, style),
258 );
259 }
260 if self.borders.contains(Borders::LEFT | Borders::BOTTOM) {
261 buf.set_fast(
262 area.x,
263 area.bottom() - 1,
264 self.border_cell(set.bottom_left, style),
265 );
266 }
267 if self.borders.contains(Borders::RIGHT | Borders::BOTTOM) {
268 buf.set_fast(
269 area.right() - 1,
270 area.bottom() - 1,
271 self.border_cell(set.bottom_right, style),
272 );
273 }
274 }
275
276 fn render_title(&self, area: Rect, frame: &mut Frame) {
277 if let Some(title) = self.title {
278 if !self.borders.contains(Borders::TOP) || area.width < 3 {
279 return;
280 }
281
282 let available_width = area.width.saturating_sub(2) as usize;
283 if available_width == 0 {
284 return;
285 }
286
287 let display_width = fitted_text_width(title, available_width);
288 if display_width == 0 {
289 return;
290 }
291
292 let x = match self.title_alignment {
293 Alignment::Left => area.x.saturating_add(1),
294 Alignment::Center => area
295 .x
296 .saturating_add(1)
297 .saturating_add(((available_width.saturating_sub(display_width)) / 2) as u16),
298 Alignment::Right => area
299 .right()
300 .saturating_sub(1)
301 .saturating_sub(display_width as u16),
302 };
303
304 let max_x = area.right().saturating_sub(1);
305 draw_text_span(frame, x, area.y, title, self.border_style, max_x);
306 }
307 }
308}
309
310impl Widget for Block<'_> {
311 fn render(&self, area: Rect, frame: &mut Frame) {
312 if frame.a11y_enabled() {
313 frame.push_a11y_nodes(ftui_a11y::Accessible::accessibility_nodes(self, area));
314 }
315 #[cfg(feature = "tracing")]
316 let _span = tracing::debug_span!(
317 "widget_render",
318 widget = "Block",
319 x = area.x,
320 y = area.y,
321 w = area.width,
322 h = area.height
323 )
324 .entered();
325
326 if area.is_empty() {
327 return;
328 }
329
330 let deg = frame.degradation;
331 let border_style = if deg.apply_styling() {
332 self.border_style
333 } else {
334 Style::default()
335 };
336
337 if !deg.render_content() {
339 frame.buffer.fill(area, Cell::default());
340 return;
341 }
342
343 if !deg.render_decorative() {
346 frame.buffer.fill(area, Cell::default());
347 if deg.apply_styling() {
348 set_style_area(&mut frame.buffer, area, self.style);
349 }
350 return;
351 }
352
353 if deg.apply_styling() {
355 set_style_area(&mut frame.buffer, area, self.style);
356 }
357
358 if deg.use_unicode_borders() {
360 self.render_borders(area, &mut frame.buffer, border_style);
361 } else {
362 self.render_borders_ascii(area, &mut frame.buffer, border_style);
364 }
365
366 if deg.apply_styling() {
368 self.render_title(area, frame);
369 } else if deg.render_decorative() {
370 if let Some(title) = self.title
373 && self.borders.contains(Borders::TOP)
374 && area.width >= 3
375 {
376 let available_width = area.width.saturating_sub(2) as usize;
377 if available_width > 0 {
378 let display_width = fitted_text_width(title, available_width);
379 if display_width == 0 {
380 return;
381 }
382 let x = match self.title_alignment {
383 Alignment::Left => area.x.saturating_add(1),
384 Alignment::Center => area.x.saturating_add(1).saturating_add(
385 ((available_width.saturating_sub(display_width)) / 2) as u16,
386 ),
387 Alignment::Right => area
388 .right()
389 .saturating_sub(1)
390 .saturating_sub(display_width as u16),
391 };
392 let max_x = area.right().saturating_sub(1);
393 frame.buffer.fill(
396 Rect::new(x, area.y, display_width as u16, 1),
397 Cell::default(),
398 );
399 draw_text_span(frame, x, area.y, title, Style::default(), max_x);
400 }
401 }
402 }
403 }
404}
405
406impl MeasurableWidget for Block<'_> {
407 fn measure(&self, _available: Size) -> SizeConstraints {
408 let (chrome_width, chrome_height) = self.chrome_size();
409 let chrome = Size::new(chrome_width, chrome_height);
410
411 SizeConstraints::at_least(chrome, chrome)
416 }
417
418 fn has_intrinsic_size(&self) -> bool {
419 self.borders != Borders::empty()
421 }
422}
423
424fn fitted_text_width(text: &str, max_width: usize) -> usize {
425 let mut width = 0usize;
426 for grapheme in graphemes(text) {
427 let w = grapheme_width(grapheme);
428 if w == 0 {
429 continue;
430 }
431 if width.saturating_add(w) > max_width {
432 break;
433 }
434 width += w;
435 }
436 width
437}
438
439impl ftui_a11y::Accessible for Block<'_> {
444 fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
445 use ftui_a11y::node::{A11yNodeInfo, A11yRole};
446
447 let id = crate::a11y_node_id(area);
448 let mut node = A11yNodeInfo::new(id, A11yRole::Group, area);
449 if let Some(title) = self.title_text() {
450 node = node.with_name(title);
451 }
452 vec![node]
453 }
454}
455
456#[cfg(test)]
457mod tests {
458 use super::*;
459 use ftui_render::cell::PackedRgba;
460 use ftui_render::grapheme_pool::GraphemePool;
461
462 #[test]
463 fn inner_with_all_borders() {
464 let block = Block::new().borders(Borders::ALL);
465 let area = Rect::new(0, 0, 10, 10);
466 let inner = block.inner(area);
467 assert_eq!(inner, Rect::new(1, 1, 8, 8));
468 }
469
470 #[test]
471 fn inner_with_no_borders() {
472 let block = Block::new();
473 let area = Rect::new(0, 0, 10, 10);
474 let inner = block.inner(area);
475 assert_eq!(inner, area);
476 }
477
478 #[test]
479 fn inner_with_partial_borders() {
480 let block = Block::new().borders(Borders::TOP | Borders::LEFT);
481 let area = Rect::new(0, 0, 10, 10);
482 let inner = block.inner(area);
483 assert_eq!(inner, Rect::new(1, 1, 9, 9));
484 }
485
486 #[test]
487 fn render_empty_area() {
488 let block = Block::new().borders(Borders::ALL);
489 let area = Rect::new(0, 0, 0, 0);
490 let mut pool = GraphemePool::new();
491 let mut frame = Frame::new(1, 1, &mut pool);
492 block.render(area, &mut frame);
493 }
494
495 #[test]
496 fn render_block_with_square_borders() {
497 let block = Block::new()
498 .borders(Borders::ALL)
499 .border_type(BorderType::Square);
500 let area = Rect::new(0, 0, 5, 3);
501 let mut pool = GraphemePool::new();
502 let mut frame = Frame::new(5, 3, &mut pool);
503 block.render(area, &mut frame);
504
505 let buf = &frame.buffer;
506 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('┌'));
507 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('┐'));
508 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('└'));
509 assert_eq!(buf.get(4, 2).unwrap().content.as_char(), Some('┘'));
510 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('─'));
511 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('│'));
512 }
513
514 #[test]
515 fn render_block_with_dashed_borders() {
516 let block = Block::bordered().border_type(BorderType::Dashed);
517 let area = Rect::new(0, 0, 10, 3);
518 let mut pool = GraphemePool::new();
519 let mut frame = Frame::new(10, 3, &mut pool);
520 block.render(area, &mut frame);
521
522 let buf = &frame.buffer;
523 let top: String = (0..10)
524 .map(|x| buf.get(x, 0).unwrap().content.as_char().unwrap_or(' '))
525 .collect();
526 assert_eq!(top, "┌┄┄┄┄┄┄┄┄┐");
527 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('┆'));
529 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('└'));
530 assert_eq!(buf.get(9, 2).unwrap().content.as_char(), Some('┘'));
531 }
532
533 #[test]
534 fn render_block_with_title() {
535 let block = Block::new()
536 .borders(Borders::ALL)
537 .border_type(BorderType::Square)
538 .title("Hi");
539 let area = Rect::new(0, 0, 10, 3);
540 let mut pool = GraphemePool::new();
541 let mut frame = Frame::new(10, 3, &mut pool);
542 block.render(area, &mut frame);
543
544 let buf = &frame.buffer;
545 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('H'));
546 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('i'));
547 }
548
549 #[test]
550 fn render_title_overrides_on_multiple_calls() {
551 let block = Block::new()
552 .borders(Borders::ALL)
553 .border_type(BorderType::Square)
554 .title("First")
555 .title("Second");
556 let area = Rect::new(0, 0, 12, 3);
557 let mut pool = GraphemePool::new();
558 let mut frame = Frame::new(12, 3, &mut pool);
559 block.render(area, &mut frame);
560
561 let buf = &frame.buffer;
562 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('S'));
563 }
564
565 #[test]
566 fn render_block_with_background() {
567 let block = Block::new().style(Style::new().bg(PackedRgba::rgb(10, 20, 30)));
568 let area = Rect::new(0, 0, 3, 2);
569 let mut pool = GraphemePool::new();
570 let mut frame = Frame::new(3, 2, &mut pool);
571 block.render(area, &mut frame);
572
573 let buf = &frame.buffer;
574 assert_eq!(buf.get(0, 0).unwrap().bg, PackedRgba::rgb(10, 20, 30));
575 assert_eq!(buf.get(2, 1).unwrap().bg, PackedRgba::rgb(10, 20, 30));
576 }
577
578 #[test]
579 fn inner_with_only_bottom() {
580 let block = Block::new().borders(Borders::BOTTOM);
581 let area = Rect::new(0, 0, 10, 10);
582 let inner = block.inner(area);
583 assert_eq!(inner, Rect::new(0, 0, 10, 9));
584 }
585
586 #[test]
587 fn inner_with_only_right() {
588 let block = Block::new().borders(Borders::RIGHT);
589 let area = Rect::new(0, 0, 10, 10);
590 let inner = block.inner(area);
591 assert_eq!(inner, Rect::new(0, 0, 9, 10));
592 }
593
594 #[test]
595 fn inner_saturates_on_tiny_area() {
596 let block = Block::new().borders(Borders::ALL);
597 let area = Rect::new(0, 0, 1, 1);
598 let inner = block.inner(area);
599 assert_eq!(inner.width, 0);
601 }
602
603 #[test]
604 fn bordered_constructor() {
605 let block = Block::bordered();
606 assert_eq!(block.borders, Borders::ALL);
607 }
608
609 #[test]
610 fn default_has_no_borders() {
611 let block = Block::new();
612 assert_eq!(block.borders, Borders::empty());
613 assert!(block.title.is_none());
614 }
615
616 #[test]
617 fn render_rounded_borders() {
618 let block = Block::new()
619 .borders(Borders::ALL)
620 .border_type(BorderType::Rounded);
621 let area = Rect::new(0, 0, 5, 3);
622 let mut pool = GraphemePool::new();
623 let mut frame = Frame::new(5, 3, &mut pool);
624 block.render(area, &mut frame);
625
626 let buf = &frame.buffer;
627 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('╭'));
628 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('╮'));
629 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('╰'));
630 assert_eq!(buf.get(4, 2).unwrap().content.as_char(), Some('╯'));
631 }
632
633 #[test]
634 fn render_double_borders() {
635 let block = Block::new()
636 .borders(Borders::ALL)
637 .border_type(BorderType::Double);
638 let area = Rect::new(0, 0, 5, 3);
639 let mut pool = GraphemePool::new();
640 let mut frame = Frame::new(5, 3, &mut pool);
641 block.render(area, &mut frame);
642
643 let buf = &frame.buffer;
644 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('╔'));
645 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('╗'));
646 }
647
648 #[test]
649 fn render_partial_borders_corners_only_when_edges_enabled() {
650 let block = Block::new()
651 .borders(Borders::TOP | Borders::LEFT | Borders::BOTTOM)
652 .border_type(BorderType::Square);
653 let area = Rect::new(0, 0, 4, 3);
654 let mut pool = GraphemePool::new();
655 let mut frame = Frame::new(4, 3, &mut pool);
656 block.render(area, &mut frame);
657
658 let buf = &frame.buffer;
659 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('┌'));
660 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('└'));
661 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('─'));
662 assert_eq!(buf.get(3, 2).unwrap().content.as_char(), Some('─'));
663 assert!(
664 buf.get(3, 1).unwrap().is_empty()
665 || buf.get(3, 1).unwrap().content.as_char() == Some(' ')
666 );
667 }
668
669 #[test]
670 fn render_vertical_only_borders_use_vertical_glyphs() {
671 let block = Block::new()
672 .borders(Borders::LEFT | Borders::RIGHT)
673 .border_type(BorderType::Double);
674 let area = Rect::new(0, 0, 4, 3);
675 let mut pool = GraphemePool::new();
676 let mut frame = Frame::new(4, 3, &mut pool);
677 block.render(area, &mut frame);
678
679 let buf = &frame.buffer;
680 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('║'));
681 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('║'));
682 assert!(
683 buf.get(1, 0).unwrap().is_empty()
684 || buf.get(1, 0).unwrap().content.as_char() == Some(' ')
685 );
686 }
687
688 #[test]
689 fn render_missing_left_keeps_horizontal_corner_logic() {
690 let block = Block::new()
691 .borders(Borders::TOP | Borders::RIGHT | Borders::BOTTOM)
692 .border_type(BorderType::Square);
693 let area = Rect::new(0, 0, 4, 3);
694 let mut pool = GraphemePool::new();
695 let mut frame = Frame::new(4, 3, &mut pool);
696 block.render(area, &mut frame);
697
698 let buf = &frame.buffer;
699 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('─'));
700 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('┐'));
701 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('─'));
702 assert_eq!(buf.get(3, 2).unwrap().content.as_char(), Some('┘'));
703 assert_eq!(buf.get(3, 1).unwrap().content.as_char(), Some('│'));
704 }
705
706 #[test]
707 fn render_title_left_aligned() {
708 let block = Block::new()
709 .borders(Borders::ALL)
710 .title("Test")
711 .title_alignment(Alignment::Left);
712 let area = Rect::new(0, 0, 10, 3);
713 let mut pool = GraphemePool::new();
714 let mut frame = Frame::new(10, 3, &mut pool);
715 block.render(area, &mut frame);
716
717 let buf = &frame.buffer;
718 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('T'));
719 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('e'));
720 }
721
722 #[test]
723 fn render_title_center_aligned() {
724 let block = Block::new()
725 .borders(Borders::ALL)
726 .title("Hi")
727 .title_alignment(Alignment::Center);
728 let area = Rect::new(0, 0, 10, 3);
729 let mut pool = GraphemePool::new();
730 let mut frame = Frame::new(10, 3, &mut pool);
731 block.render(area, &mut frame);
732
733 let buf = &frame.buffer;
735 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('H'));
736 assert_eq!(buf.get(5, 0).unwrap().content.as_char(), Some('i'));
737 }
738
739 #[test]
740 fn render_title_center_aligned_with_wide_grapheme() {
741 let block = Block::new()
742 .borders(Borders::ALL)
743 .title("界")
744 .title_alignment(Alignment::Center);
745 let area = Rect::new(0, 0, 8, 3);
746 let mut pool = GraphemePool::new();
747 let mut frame = Frame::new(8, 3, &mut pool);
748 block.render(area, &mut frame);
749
750 let buf = &frame.buffer;
752 let cell = buf.get(3, 0).unwrap();
753 assert!(
754 cell.content.as_char() == Some('界') || cell.content.is_grapheme(),
755 "expected title grapheme at x=3"
756 );
757 assert!(buf.get(4, 0).unwrap().is_continuation());
758 }
759
760 #[test]
761 fn render_title_right_aligned() {
762 let block = Block::new()
763 .borders(Borders::ALL)
764 .title("Hi")
765 .title_alignment(Alignment::Right);
766 let area = Rect::new(0, 0, 10, 3);
767 let mut pool = GraphemePool::new();
768 let mut frame = Frame::new(10, 3, &mut pool);
769 block.render(area, &mut frame);
770
771 let buf = &frame.buffer;
772 assert_eq!(buf.get(7, 0).unwrap().content.as_char(), Some('H'));
774 assert_eq!(buf.get(8, 0).unwrap().content.as_char(), Some('i'));
775 }
776
777 #[test]
778 fn render_title_right_aligned_truncated_wide_grapheme_uses_fitted_width() {
779 let block = Block::new()
780 .borders(Borders::ALL)
781 .title("界界")
782 .title_alignment(Alignment::Right);
783 let area = Rect::new(0, 0, 5, 3);
784 let mut pool = GraphemePool::new();
785 let mut frame = Frame::new(5, 3, &mut pool);
786 block.render(area, &mut frame);
787
788 let buf = &frame.buffer;
789 let cell = buf.get(2, 0).unwrap();
790 assert!(
791 cell.content.as_char() == Some('界') || cell.content.is_grapheme(),
792 "expected fitted wide title to be right aligned"
793 );
794 assert!(buf.get(3, 0).unwrap().is_continuation());
795 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('─'));
796 }
797
798 #[test]
799 fn render_multi_title_alignment_uses_last_title_and_alignment() {
800 let block = Block::new()
801 .borders(Borders::ALL)
802 .title("Left")
803 .title_alignment(Alignment::Left)
804 .title("Right")
805 .title_alignment(Alignment::Right);
806 let area = Rect::new(0, 0, 12, 3);
807 let mut pool = GraphemePool::new();
808 let mut frame = Frame::new(12, 3, &mut pool);
809 block.render(area, &mut frame);
810
811 let buf = &frame.buffer;
812 assert_eq!(buf.get(6, 0).unwrap().content.as_char(), Some('R'));
813 assert_ne!(buf.get(1, 0).unwrap().content.as_char(), Some('L'));
814 }
815
816 #[test]
817 fn title_not_rendered_without_top_border() {
818 let block = Block::new()
819 .borders(Borders::LEFT | Borders::RIGHT | Borders::BOTTOM)
820 .title("Hi");
821 let area = Rect::new(0, 0, 10, 3);
822 let mut pool = GraphemePool::new();
823 let mut frame = Frame::new(10, 3, &mut pool);
824 block.render(area, &mut frame);
825
826 let buf = &frame.buffer;
827 assert_ne!(buf.get(1, 0).unwrap().content.as_char(), Some('H'));
829 }
830
831 #[test]
832 fn border_style_applied() {
833 let block = Block::new()
834 .borders(Borders::ALL)
835 .border_style(Style::new().fg(PackedRgba::rgb(255, 0, 0)));
836 let area = Rect::new(0, 0, 5, 3);
837 let mut pool = GraphemePool::new();
838 let mut frame = Frame::new(5, 3, &mut pool);
839 block.render(area, &mut frame);
840
841 let buf = &frame.buffer;
842 assert_eq!(buf.get(0, 0).unwrap().fg, PackedRgba::rgb(255, 0, 0));
843 }
844
845 #[test]
846 fn only_horizontal_borders() {
847 let block = Block::new()
848 .borders(Borders::TOP | Borders::BOTTOM)
849 .border_type(BorderType::Square);
850 let area = Rect::new(0, 0, 5, 3);
851 let mut pool = GraphemePool::new();
852 let mut frame = Frame::new(5, 3, &mut pool);
853 block.render(area, &mut frame);
854
855 let buf = &frame.buffer;
856 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('─'));
858 assert_eq!(buf.get(2, 2).unwrap().content.as_char(), Some('─'));
859 assert!(
861 buf.get(0, 1).unwrap().is_empty()
862 || buf.get(0, 1).unwrap().content.as_char() == Some(' ')
863 );
864 }
865
866 #[test]
867 fn degradation_simple_borders_forces_ascii() {
868 use ftui_render::budget::DegradationLevel;
869
870 let block = Block::new()
871 .borders(Borders::ALL)
872 .border_type(BorderType::Rounded);
873 let area = Rect::new(0, 0, 5, 3);
874 let mut pool = GraphemePool::new();
875 let mut frame = Frame::new(5, 3, &mut pool);
876 frame.set_degradation(DegradationLevel::SimpleBorders);
877 block.render(area, &mut frame);
878
879 let buf = &frame.buffer;
880 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('+'));
881 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('+'));
882 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('-'));
883 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('|'));
884 }
885
886 #[test]
887 fn degradation_simple_borders_partial_edges_use_ascii_corners() {
888 use ftui_render::budget::DegradationLevel;
889
890 let block = Block::new()
891 .borders(Borders::TOP | Borders::RIGHT | Borders::BOTTOM)
892 .border_type(BorderType::Double);
893 let area = Rect::new(0, 0, 4, 3);
894 let mut pool = GraphemePool::new();
895 let mut frame = Frame::new(4, 3, &mut pool);
896 frame.set_degradation(DegradationLevel::SimpleBorders);
897 block.render(area, &mut frame);
898
899 let buf = &frame.buffer;
900 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('-'));
901 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('+'));
902 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('-'));
903 assert_eq!(buf.get(3, 2).unwrap().content.as_char(), Some('+'));
904 assert_eq!(buf.get(3, 1).unwrap().content.as_char(), Some('|'));
905 }
906
907 #[test]
908 fn degradation_no_styling_renders_title_without_styles() {
909 use ftui_render::budget::DegradationLevel;
910
911 let block = Block::new()
912 .borders(Borders::ALL)
913 .border_style(Style::new().fg(PackedRgba::rgb(200, 0, 0)))
914 .title("Hi");
915 let area = Rect::new(0, 0, 6, 3);
916 let mut pool = GraphemePool::new();
917 let mut frame = Frame::new(6, 3, &mut pool);
918 frame.set_degradation(DegradationLevel::NoStyling);
919 block.render(area, &mut frame);
920
921 let buf = &frame.buffer;
922 let default_fg = Cell::default().fg;
923 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('H'));
924 assert_eq!(buf.get(1, 0).unwrap().fg, default_fg);
925 }
926
927 #[test]
928 fn degradation_no_styling_keeps_border_when_title_does_not_fit() {
929 use ftui_render::budget::DegradationLevel;
930
931 let titled = Block::new()
932 .borders(Borders::ALL)
933 .border_type(BorderType::Square)
934 .title("界");
935 let plain = Block::new()
936 .borders(Borders::ALL)
937 .border_type(BorderType::Square);
938 let area = Rect::new(0, 0, 3, 3);
939
940 let mut titled_pool = GraphemePool::new();
941 let mut titled_frame = Frame::new(3, 3, &mut titled_pool);
942 titled_frame.set_degradation(DegradationLevel::NoStyling);
943 titled.render(area, &mut titled_frame);
944
945 let mut plain_pool = GraphemePool::new();
946 let mut plain_frame = Frame::new(3, 3, &mut plain_pool);
947 plain_frame.set_degradation(DegradationLevel::NoStyling);
948 plain.render(area, &mut plain_frame);
949
950 assert_eq!(titled_frame.buffer.get(1, 0), plain_frame.buffer.get(1, 0));
951 }
952
953 #[test]
954 fn degradation_no_styling_drops_border_style_everywhere() {
955 use ftui_render::budget::DegradationLevel;
956
957 let block = Block::new()
958 .borders(Borders::ALL)
959 .border_style(Style::new().fg(PackedRgba::rgb(200, 0, 0)).bold());
960 let area = Rect::new(0, 0, 5, 3);
961 let mut pool = GraphemePool::new();
962 let mut frame = Frame::new(5, 3, &mut pool);
963 frame.set_degradation(DegradationLevel::NoStyling);
964 block.render(area, &mut frame);
965
966 let border = frame.buffer.get(0, 0).unwrap();
967 let default_cell = Cell::from_char(border.content.as_char().unwrap());
968 assert_eq!(border.fg, default_cell.fg);
969 assert_eq!(border.bg, default_cell.bg);
970 assert_eq!(border.attrs, default_cell.attrs);
971 }
972
973 #[test]
974 fn degradation_essential_only_clears_stale_borders_and_title() {
975 use ftui_render::budget::DegradationLevel;
976
977 let block = Block::bordered()
978 .border_type(BorderType::Square)
979 .title("Hi");
980 let area = Rect::new(0, 0, 6, 3);
981 let mut pool = GraphemePool::new();
982 let mut frame = Frame::new(6, 3, &mut pool);
983 block.render(area, &mut frame);
984
985 frame.set_degradation(DegradationLevel::EssentialOnly);
986 block.render(area, &mut frame);
987
988 let buf = &frame.buffer;
989 for y in 0..area.height {
990 for x in 0..area.width {
991 assert!(
992 buf.get(x, y).unwrap().is_empty(),
993 "expected cleared cell at ({x}, {y}), got {:?}",
994 buf.get(x, y).unwrap()
995 );
996 }
997 }
998 }
999
1000 #[test]
1001 fn degradation_skeleton_clears_area() {
1002 use ftui_render::budget::DegradationLevel;
1003
1004 let block = Block::bordered();
1005 let area = Rect::new(0, 0, 3, 2);
1006 let mut pool = GraphemePool::new();
1007 let mut frame = Frame::new(3, 2, &mut pool);
1008 frame.buffer.fill(area, Cell::from_char('X'));
1009 frame.set_degradation(DegradationLevel::Skeleton);
1010 block.render(area, &mut frame);
1011
1012 let buf = &frame.buffer;
1013 assert!(buf.get(0, 0).unwrap().is_empty());
1014 }
1015
1016 #[test]
1017 fn block_equality() {
1018 let a = Block::new().borders(Borders::ALL).title("Test");
1019 let b = Block::new().borders(Borders::ALL).title("Test");
1020 assert_eq!(a, b);
1021 }
1022
1023 #[test]
1024 fn render_1x1_no_panic() {
1025 let block = Block::bordered();
1026 let area = Rect::new(0, 0, 1, 1);
1027 let mut pool = GraphemePool::new();
1028 let mut frame = Frame::new(1, 1, &mut pool);
1029 block.render(area, &mut frame);
1030 }
1031
1032 #[test]
1033 fn render_2x2_with_borders() {
1034 let block = Block::bordered().border_type(BorderType::Square);
1035 let area = Rect::new(0, 0, 2, 2);
1036 let mut pool = GraphemePool::new();
1037 let mut frame = Frame::new(2, 2, &mut pool);
1038 block.render(area, &mut frame);
1039
1040 let buf = &frame.buffer;
1041 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('┌'));
1042 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('┐'));
1043 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('└'));
1044 assert_eq!(buf.get(1, 1).unwrap().content.as_char(), Some('┘'));
1045 }
1046
1047 #[test]
1048 fn title_too_narrow() {
1049 let block = Block::bordered().title("LongTitle");
1051 let area = Rect::new(0, 0, 4, 3);
1052 let mut pool = GraphemePool::new();
1053 let mut frame = Frame::new(4, 3, &mut pool);
1054 block.render(area, &mut frame);
1055 }
1057
1058 #[test]
1059 fn alignment_default_is_left() {
1060 assert_eq!(Alignment::default(), Alignment::Left);
1061 }
1062
1063 use crate::MeasurableWidget;
1066 use ftui_core::geometry::Size;
1067
1068 #[test]
1069 fn chrome_size_no_borders() {
1070 let block = Block::new();
1071 assert_eq!(block.chrome_size(), (0, 0));
1072 }
1073
1074 #[test]
1075 fn chrome_size_all_borders() {
1076 let block = Block::bordered();
1077 assert_eq!(block.chrome_size(), (4, 4));
1080 }
1081
1082 #[test]
1083 fn chrome_size_partial_borders() {
1084 let block = Block::new().borders(Borders::TOP | Borders::LEFT);
1085 assert_eq!(block.chrome_size(), (1, 1));
1086 }
1087
1088 #[test]
1089 fn chrome_size_horizontal_only() {
1090 let block = Block::new().borders(Borders::LEFT | Borders::RIGHT);
1091 assert_eq!(block.chrome_size(), (2, 0));
1092 }
1093
1094 #[test]
1095 fn chrome_size_vertical_only() {
1096 let block = Block::new().borders(Borders::TOP | Borders::BOTTOM);
1097 assert_eq!(block.chrome_size(), (0, 2));
1098 }
1099
1100 #[test]
1101 fn measure_no_borders() {
1102 let block = Block::new();
1103 let constraints = block.measure(Size::MAX);
1104 assert_eq!(constraints.min, Size::ZERO);
1105 assert_eq!(constraints.preferred, Size::ZERO);
1106 }
1107
1108 #[test]
1109 fn measure_all_borders() {
1110 let block = Block::bordered();
1111 let constraints = block.measure(Size::MAX);
1112 assert_eq!(constraints.min, Size::new(4, 4));
1113 assert_eq!(constraints.preferred, Size::new(4, 4));
1114 assert_eq!(constraints.max, None); }
1116
1117 #[test]
1118 fn measure_partial_borders() {
1119 let block = Block::new().borders(Borders::TOP | Borders::RIGHT);
1120 let constraints = block.measure(Size::MAX);
1121 assert_eq!(constraints.min, Size::new(1, 1));
1122 assert_eq!(constraints.preferred, Size::new(1, 1));
1123 }
1124
1125 #[test]
1126 fn has_intrinsic_size_with_borders() {
1127 let block = Block::bordered();
1128 assert!(block.has_intrinsic_size());
1129 }
1130
1131 #[test]
1132 fn has_no_intrinsic_size_without_borders() {
1133 let block = Block::new();
1134 assert!(!block.has_intrinsic_size());
1135 }
1136
1137 #[test]
1138 fn measure_is_pure() {
1139 let block = Block::bordered();
1140 let a = block.measure(Size::new(100, 50));
1141 let b = block.measure(Size::new(100, 50));
1142 assert_eq!(a, b);
1143 }
1144}