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, StyleSheet};
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, Hash, 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]
61 pub fn styled(sheet: &StyleSheet, name: &str) -> Self {
62 Self::default().with_stylesheet(sheet, name)
63 }
64
65 #[must_use]
75 pub fn with_stylesheet(mut self, sheet: &StyleSheet, name: &str) -> Self {
76 self.style = sheet.get_or_default(name);
77 self.border_style = sheet.compose(&[
78 name,
79 &format!("{name}{}", crate::style_names::BLOCK_BORDER_SUFFIX),
80 ]);
81 self
82 }
83
84 #[must_use]
86 pub fn borders(mut self, borders: Borders) -> Self {
87 self.borders = borders;
88 self
89 }
90
91 #[must_use]
93 pub fn border_style(mut self, style: Style) -> Self {
94 self.border_style = style;
95 self
96 }
97
98 #[must_use]
100 pub fn border_type(mut self, border_type: BorderType) -> Self {
101 self.border_type = border_type;
102 self
103 }
104
105 #[must_use]
107 pub fn padding(mut self, padding: impl Into<Sides>) -> Self {
108 self.padding = padding.into();
109 self
110 }
111
112 pub(crate) fn border_set(&self) -> BorderSet {
114 self.border_type.to_border_set()
115 }
116
117 #[must_use]
119 pub fn title(mut self, title: &'a str) -> Self {
120 self.title = Some(title);
121 self
122 }
123
124 #[must_use]
126 pub fn title_text(&self) -> Option<&str> {
127 self.title
128 }
129
130 #[must_use]
132 pub fn title_alignment(mut self, alignment: Alignment) -> Self {
133 self.title_alignment = alignment;
134 self
135 }
136
137 #[must_use]
139 pub fn style(mut self, style: Style) -> Self {
140 self.style = style;
141 self
142 }
143
144 #[must_use]
146 pub fn inner(&self, area: Rect) -> Rect {
147 let mut inner = area;
148
149 if self.borders.contains(Borders::LEFT) {
150 inner.x = inner.x.saturating_add(1);
151 inner.width = inner.width.saturating_sub(1);
152 }
153 if self.borders.contains(Borders::TOP) {
154 inner.y = inner.y.saturating_add(1);
155 inner.height = inner.height.saturating_sub(1);
156 }
157 if self.borders.contains(Borders::RIGHT) {
158 inner.width = inner.width.saturating_sub(1);
159 }
160 if self.borders.contains(Borders::BOTTOM) {
161 inner.height = inner.height.saturating_sub(1);
162 }
163
164 inner.inner(self.padding)
165 }
166
167 #[must_use]
172 pub fn chrome_size(&self) -> (u16, u16) {
173 let border_h = self.borders.contains(Borders::LEFT) as u16
174 + self.borders.contains(Borders::RIGHT) as u16;
175 let border_v = self.borders.contains(Borders::TOP) as u16
176 + self.borders.contains(Borders::BOTTOM) as u16;
177
178 let padding_h = self.padding.left + self.padding.right;
179 let padding_v = self.padding.top + self.padding.bottom;
180
181 (
182 border_h.saturating_add(padding_h),
183 border_v.saturating_add(padding_v),
184 )
185 }
186
187 fn border_cell(&self, c: char, style: Style) -> Cell {
189 let mut cell = Cell::from_char(c);
190 apply_style(&mut cell, style);
191 cell
192 }
193
194 fn render_borders(&self, area: Rect, buf: &mut Buffer, style: Style) {
195 if area.is_empty() {
196 return;
197 }
198
199 let set = self.border_set();
200
201 if self.borders.contains(Borders::LEFT) {
203 for y in area.y..area.bottom() {
204 buf.set_fast(area.x, y, self.border_cell(set.vertical, style));
205 }
206 }
207 if self.borders.contains(Borders::RIGHT) {
208 let x = area.right() - 1;
209 for y in area.y..area.bottom() {
210 buf.set_fast(x, y, self.border_cell(set.vertical, style));
211 }
212 }
213 if self.borders.contains(Borders::TOP) {
214 for x in area.x..area.right() {
215 buf.set_fast(x, area.y, self.border_cell(set.horizontal, style));
216 }
217 }
218 if self.borders.contains(Borders::BOTTOM) {
219 let y = area.bottom() - 1;
220 for x in area.x..area.right() {
221 buf.set_fast(x, y, self.border_cell(set.horizontal, style));
222 }
223 }
224
225 if self.borders.contains(Borders::LEFT | Borders::TOP) {
227 buf.set_fast(area.x, area.y, self.border_cell(set.top_left, style));
228 }
229 if self.borders.contains(Borders::RIGHT | Borders::TOP) {
230 buf.set_fast(
231 area.right() - 1,
232 area.y,
233 self.border_cell(set.top_right, style),
234 );
235 }
236 if self.borders.contains(Borders::LEFT | Borders::BOTTOM) {
237 buf.set_fast(
238 area.x,
239 area.bottom() - 1,
240 self.border_cell(set.bottom_left, style),
241 );
242 }
243 if self.borders.contains(Borders::RIGHT | Borders::BOTTOM) {
244 buf.set_fast(
245 area.right() - 1,
246 area.bottom() - 1,
247 self.border_cell(set.bottom_right, style),
248 );
249 }
250 }
251
252 fn render_borders_ascii(&self, area: Rect, buf: &mut Buffer, style: Style) {
254 if area.is_empty() {
255 return;
256 }
257
258 let set = crate::borders::BorderSet::ASCII;
259
260 if self.borders.contains(Borders::LEFT) {
261 for y in area.y..area.bottom() {
262 buf.set_fast(area.x, y, self.border_cell(set.vertical, style));
263 }
264 }
265 if self.borders.contains(Borders::RIGHT) {
266 let x = area.right() - 1;
267 for y in area.y..area.bottom() {
268 buf.set_fast(x, y, self.border_cell(set.vertical, style));
269 }
270 }
271 if self.borders.contains(Borders::TOP) {
272 for x in area.x..area.right() {
273 buf.set_fast(x, area.y, self.border_cell(set.horizontal, style));
274 }
275 }
276 if self.borders.contains(Borders::BOTTOM) {
277 let y = area.bottom() - 1;
278 for x in area.x..area.right() {
279 buf.set_fast(x, y, self.border_cell(set.horizontal, style));
280 }
281 }
282
283 if self.borders.contains(Borders::LEFT | Borders::TOP) {
284 buf.set_fast(area.x, area.y, self.border_cell(set.top_left, style));
285 }
286 if self.borders.contains(Borders::RIGHT | Borders::TOP) {
287 buf.set_fast(
288 area.right() - 1,
289 area.y,
290 self.border_cell(set.top_right, style),
291 );
292 }
293 if self.borders.contains(Borders::LEFT | Borders::BOTTOM) {
294 buf.set_fast(
295 area.x,
296 area.bottom() - 1,
297 self.border_cell(set.bottom_left, style),
298 );
299 }
300 if self.borders.contains(Borders::RIGHT | Borders::BOTTOM) {
301 buf.set_fast(
302 area.right() - 1,
303 area.bottom() - 1,
304 self.border_cell(set.bottom_right, style),
305 );
306 }
307 }
308
309 fn render_title(&self, area: Rect, frame: &mut Frame) {
310 if let Some(title) = self.title {
311 if !self.borders.contains(Borders::TOP) || area.width < 3 {
312 return;
313 }
314
315 let available_width = area.width.saturating_sub(2) as usize;
316 if available_width == 0 {
317 return;
318 }
319
320 let display_width = fitted_text_width(title, available_width);
321 if display_width == 0 {
322 return;
323 }
324
325 let x = match self.title_alignment {
326 Alignment::Left => area.x.saturating_add(1),
327 Alignment::Center => area
328 .x
329 .saturating_add(1)
330 .saturating_add(((available_width.saturating_sub(display_width)) / 2) as u16),
331 Alignment::Right => area
332 .right()
333 .saturating_sub(1)
334 .saturating_sub(display_width as u16),
335 };
336
337 let max_x = area.right().saturating_sub(1);
338 draw_text_span(frame, x, area.y, title, self.border_style, max_x);
339 }
340 }
341
342 pub fn render_with_children<F>(&self, area: Rect, frame: &mut Frame, children: F)
345 where
346 F: FnOnce(Rect, &mut Frame),
347 {
348 let inner = self.inner(area);
349 if !area.is_empty() && frame.a11y_enabled() {
350 crate::render_block_without_a11y(self, area, frame);
351 let mut nodes = ftui_a11y::Accessible::accessibility_nodes(self, area);
352 if let Some(container) = nodes.pop() {
353 frame.with_a11y_scope(container, |frame| children(inner, frame));
354 return;
355 }
356 }
357 self.render(area, frame);
358 children(inner, frame);
359 }
360}
361
362impl Widget for Block<'_> {
363 fn render(&self, area: Rect, frame: &mut Frame) {
364 #[cfg(feature = "tracing")]
365 let _span = tracing::debug_span!(
366 "widget_render",
367 widget = "Block",
368 x = area.x,
369 y = area.y,
370 w = area.width,
371 h = area.height
372 )
373 .entered();
374
375 if area.is_empty() {
376 return;
377 }
378
379 if frame.a11y_enabled() {
387 frame.push_a11y_nodes(ftui_a11y::Accessible::accessibility_nodes(self, area));
388 }
389
390 let deg = frame.degradation;
391 let border_style = if deg.apply_styling() {
392 self.border_style
393 } else {
394 Style::default()
395 };
396
397 if !deg.render_content() {
399 frame.buffer.fill(area, Cell::default());
400 return;
401 }
402
403 if !deg.render_decorative() {
406 frame.buffer.fill(area, Cell::default());
407 if deg.apply_styling() {
408 set_style_area(&mut frame.buffer, area, self.style);
409 }
410 return;
411 }
412
413 if deg.apply_styling() {
415 set_style_area(&mut frame.buffer, area, self.style);
416 }
417
418 if deg.use_unicode_borders() {
420 self.render_borders(area, &mut frame.buffer, border_style);
421 } else {
422 self.render_borders_ascii(area, &mut frame.buffer, border_style);
424 }
425
426 if deg.apply_styling() {
428 self.render_title(area, frame);
429 } else if deg.render_decorative() {
430 if let Some(title) = self.title
433 && self.borders.contains(Borders::TOP)
434 && area.width >= 3
435 {
436 let available_width = area.width.saturating_sub(2) as usize;
437 if available_width > 0 {
438 let display_width = fitted_text_width(title, available_width);
439 if display_width == 0 {
440 return;
441 }
442 let x = match self.title_alignment {
443 Alignment::Left => area.x.saturating_add(1),
444 Alignment::Center => area.x.saturating_add(1).saturating_add(
445 ((available_width.saturating_sub(display_width)) / 2) as u16,
446 ),
447 Alignment::Right => area
448 .right()
449 .saturating_sub(1)
450 .saturating_sub(display_width as u16),
451 };
452 let max_x = area.right().saturating_sub(1);
453 frame.buffer.fill(
456 Rect::new(x, area.y, display_width as u16, 1),
457 Cell::default(),
458 );
459 draw_text_span(frame, x, area.y, title, Style::default(), max_x);
460 }
461 }
462 }
463 }
464}
465
466impl MeasurableWidget for Block<'_> {
467 fn measure(&self, _available: Size) -> SizeConstraints {
468 let (chrome_width, chrome_height) = self.chrome_size();
469 let chrome = Size::new(chrome_width, chrome_height);
470
471 SizeConstraints::at_least(chrome, chrome)
476 }
477
478 fn has_intrinsic_size(&self) -> bool {
479 self.borders != Borders::empty()
481 }
482}
483
484fn fitted_text_width(text: &str, max_width: usize) -> usize {
485 let mut width = 0usize;
486 for grapheme in graphemes(text) {
487 let w = grapheme_width(grapheme);
488 if w == 0 {
489 continue;
490 }
491 if width.saturating_add(w) > max_width {
492 break;
493 }
494 width += w;
495 }
496 width
497}
498
499impl ftui_a11y::Accessible for Block<'_> {
504 fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
505 use ftui_a11y::node::{A11yNodeInfo, A11yRole};
506
507 let id = crate::a11y_node_id(area);
508 let mut node = A11yNodeInfo::new(id, A11yRole::Group, area);
509 if let Some(title) = self.title_text() {
510 node = node.with_name(title);
511 }
512 vec![node]
513 }
514}
515
516#[cfg(test)]
517mod tests {
518 use super::*;
519 use crate::borders::BorderSet;
520 use ftui_render::cell::PackedRgba;
521 use ftui_render::grapheme_pool::GraphemePool;
522
523 #[test]
524 fn inner_with_all_borders() {
525 let block = Block::new().borders(Borders::ALL);
526 let area = Rect::new(0, 0, 10, 10);
527 let inner = block.inner(area);
528 assert_eq!(inner, Rect::new(1, 1, 8, 8));
529 }
530
531 #[test]
532 fn inner_with_no_borders() {
533 let block = Block::new();
534 let area = Rect::new(0, 0, 10, 10);
535 let inner = block.inner(area);
536 assert_eq!(inner, area);
537 }
538
539 #[test]
540 fn inner_with_partial_borders() {
541 let block = Block::new().borders(Borders::TOP | Borders::LEFT);
542 let area = Rect::new(0, 0, 10, 10);
543 let inner = block.inner(area);
544 assert_eq!(inner, Rect::new(1, 1, 9, 9));
545 }
546
547 #[test]
548 fn render_empty_area() {
549 let block = Block::new().borders(Borders::ALL);
550 let area = Rect::new(0, 0, 0, 0);
551 let mut pool = GraphemePool::new();
552 let mut frame = Frame::new(1, 1, &mut pool);
553 block.render(area, &mut frame);
554 }
555
556 #[test]
557 fn render_block_with_square_borders() {
558 let block = Block::new()
559 .borders(Borders::ALL)
560 .border_type(BorderType::Square);
561 let area = Rect::new(0, 0, 5, 3);
562 let mut pool = GraphemePool::new();
563 let mut frame = Frame::new(5, 3, &mut pool);
564 block.render(area, &mut frame);
565
566 let buf = &frame.buffer;
567 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('┌'));
568 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('┐'));
569 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('└'));
570 assert_eq!(buf.get(4, 2).unwrap().content.as_char(), Some('┘'));
571 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('─'));
572 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('│'));
573 }
574
575 #[test]
576 fn render_block_with_dashed_borders() {
577 let block = Block::bordered().border_type(BorderType::Dashed);
578 let area = Rect::new(0, 0, 10, 3);
579 let mut pool = GraphemePool::new();
580 let mut frame = Frame::new(10, 3, &mut pool);
581 block.render(area, &mut frame);
582
583 let buf = &frame.buffer;
584 let top: String = (0..10)
585 .map(|x| buf.get(x, 0).unwrap().content.as_char().unwrap_or(' '))
586 .collect();
587 assert_eq!(top, "┌┄┄┄┄┄┄┄┄┐");
588 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('┆'));
590 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('└'));
591 assert_eq!(buf.get(9, 2).unwrap().content.as_char(), Some('┘'));
592 }
593
594 #[test]
595 fn block_dashed_renders_top_row() {
596 let block = Block::bordered().border_type(BorderType::Dashed);
597 let area = Rect::new(0, 0, 10, 3);
598 let mut pool = GraphemePool::new();
599 let mut frame = Frame::new(10, 3, &mut pool);
600 block.render(area, &mut frame);
601
602 let buf = &frame.buffer;
603 let row0: String = (0..10)
604 .map(|x| buf.get(x, 0).unwrap().content.as_char().unwrap_or(' '))
605 .collect();
606 assert_eq!(row0, "┌┄┄┄┄┄┄┄┄┐");
607 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('┆'));
608 assert_eq!(buf.get(9, 1).unwrap().content.as_char(), Some('┆'));
609 let row2: String = (0..10)
610 .map(|x| buf.get(x, 2).unwrap().content.as_char().unwrap_or(' '))
611 .collect();
612 assert_eq!(row2, "└┄┄┄┄┄┄┄┄┘");
613 }
614
615 #[test]
616 fn block_custom_ascii_renders() {
617 let custom = BorderSet {
618 top_left: '#',
619 horizontal: '-',
620 top_right: '#',
621 vertical: '|',
622 bottom_left: '#',
623 bottom_right: '#',
624 tee_up: '+',
625 tee_down: '+',
626 tee_left: '+',
627 tee_right: '+',
628 cross: '+',
629 };
630 let block = Block::bordered().border_type(BorderType::Custom(custom));
631 let area = Rect::new(0, 0, 6, 3);
632 let mut pool = GraphemePool::new();
633 let mut frame = Frame::new(6, 3, &mut pool);
634 block.render(area, &mut frame);
635
636 let buf = &frame.buffer;
637 let row0: String = (0..6)
638 .map(|x| buf.get(x, 0).unwrap().content.as_char().unwrap_or(' '))
639 .collect();
640 assert_eq!(row0, "#----#");
641 }
642
643 #[test]
644 fn block_dashed_partial_borders() {
645 let block = Block::new()
646 .borders(Borders::TOP | Borders::BOTTOM)
647 .border_type(BorderType::Dashed);
648 let area = Rect::new(0, 0, 8, 3);
649 let mut pool = GraphemePool::new();
650 let mut frame = Frame::new(8, 3, &mut pool);
651 block.render(area, &mut frame);
652
653 let buf = &frame.buffer;
654 for y in 0..3 {
655 for x in 0..8 {
656 assert_ne!(
657 buf.get(x, y).unwrap().content.as_char(),
658 Some('┆'),
659 "cell ({x}, {y}) should not have vertical border"
660 );
661 }
662 }
663 let top: String = (0..8)
664 .map(|x| buf.get(x, 0).unwrap().content.as_char().unwrap_or(' '))
665 .collect();
666 let bottom: String = (0..8)
667 .map(|x| buf.get(x, 2).unwrap().content.as_char().unwrap_or(' '))
668 .collect();
669 assert_eq!(top, "┄┄┄┄┄┄┄┄");
670 assert_eq!(bottom, "┄┄┄┄┄┄┄┄");
671 }
672
673 #[test]
674 fn render_block_with_title() {
675 let block = Block::new()
676 .borders(Borders::ALL)
677 .border_type(BorderType::Square)
678 .title("Hi");
679 let area = Rect::new(0, 0, 10, 3);
680 let mut pool = GraphemePool::new();
681 let mut frame = Frame::new(10, 3, &mut pool);
682 block.render(area, &mut frame);
683
684 let buf = &frame.buffer;
685 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('H'));
686 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('i'));
687 }
688
689 #[test]
690 fn render_title_overrides_on_multiple_calls() {
691 let block = Block::new()
692 .borders(Borders::ALL)
693 .border_type(BorderType::Square)
694 .title("First")
695 .title("Second");
696 let area = Rect::new(0, 0, 12, 3);
697 let mut pool = GraphemePool::new();
698 let mut frame = Frame::new(12, 3, &mut pool);
699 block.render(area, &mut frame);
700
701 let buf = &frame.buffer;
702 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('S'));
703 }
704
705 #[test]
706 fn render_block_with_background() {
707 let block = Block::new().style(Style::new().bg(PackedRgba::rgb(10, 20, 30)));
708 let area = Rect::new(0, 0, 3, 2);
709 let mut pool = GraphemePool::new();
710 let mut frame = Frame::new(3, 2, &mut pool);
711 block.render(area, &mut frame);
712
713 let buf = &frame.buffer;
714 assert_eq!(buf.get(0, 0).unwrap().bg, PackedRgba::rgb(10, 20, 30));
715 assert_eq!(buf.get(2, 1).unwrap().bg, PackedRgba::rgb(10, 20, 30));
716 }
717
718 #[test]
719 fn inner_with_only_bottom() {
720 let block = Block::new().borders(Borders::BOTTOM);
721 let area = Rect::new(0, 0, 10, 10);
722 let inner = block.inner(area);
723 assert_eq!(inner, Rect::new(0, 0, 10, 9));
724 }
725
726 #[test]
727 fn inner_with_only_right() {
728 let block = Block::new().borders(Borders::RIGHT);
729 let area = Rect::new(0, 0, 10, 10);
730 let inner = block.inner(area);
731 assert_eq!(inner, Rect::new(0, 0, 9, 10));
732 }
733
734 #[test]
735 fn inner_saturates_on_tiny_area() {
736 let block = Block::new().borders(Borders::ALL);
737 let area = Rect::new(0, 0, 1, 1);
738 let inner = block.inner(area);
739 assert_eq!(inner.width, 0);
741 }
742
743 #[test]
744 fn bordered_constructor() {
745 let block = Block::bordered();
746 assert_eq!(block.borders, Borders::ALL);
747 }
748
749 #[test]
750 fn default_has_no_borders() {
751 let block = Block::new();
752 assert_eq!(block.borders, Borders::empty());
753 assert!(block.title.is_none());
754 }
755
756 #[test]
757 fn render_rounded_borders() {
758 let block = Block::new()
759 .borders(Borders::ALL)
760 .border_type(BorderType::Rounded);
761 let area = Rect::new(0, 0, 5, 3);
762 let mut pool = GraphemePool::new();
763 let mut frame = Frame::new(5, 3, &mut pool);
764 block.render(area, &mut frame);
765
766 let buf = &frame.buffer;
767 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('╭'));
768 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('╮'));
769 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('╰'));
770 assert_eq!(buf.get(4, 2).unwrap().content.as_char(), Some('╯'));
771 }
772
773 #[test]
774 fn render_double_borders() {
775 let block = Block::new()
776 .borders(Borders::ALL)
777 .border_type(BorderType::Double);
778 let area = Rect::new(0, 0, 5, 3);
779 let mut pool = GraphemePool::new();
780 let mut frame = Frame::new(5, 3, &mut pool);
781 block.render(area, &mut frame);
782
783 let buf = &frame.buffer;
784 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('╔'));
785 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('╗'));
786 }
787
788 #[test]
789 fn render_partial_borders_corners_only_when_edges_enabled() {
790 let block = Block::new()
791 .borders(Borders::TOP | Borders::LEFT | Borders::BOTTOM)
792 .border_type(BorderType::Square);
793 let area = Rect::new(0, 0, 4, 3);
794 let mut pool = GraphemePool::new();
795 let mut frame = Frame::new(4, 3, &mut pool);
796 block.render(area, &mut frame);
797
798 let buf = &frame.buffer;
799 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('┌'));
800 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('└'));
801 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('─'));
802 assert_eq!(buf.get(3, 2).unwrap().content.as_char(), Some('─'));
803 assert!(
804 buf.get(3, 1).unwrap().is_empty()
805 || buf.get(3, 1).unwrap().content.as_char() == Some(' ')
806 );
807 }
808
809 #[test]
810 fn render_vertical_only_borders_use_vertical_glyphs() {
811 let block = Block::new()
812 .borders(Borders::LEFT | Borders::RIGHT)
813 .border_type(BorderType::Double);
814 let area = Rect::new(0, 0, 4, 3);
815 let mut pool = GraphemePool::new();
816 let mut frame = Frame::new(4, 3, &mut pool);
817 block.render(area, &mut frame);
818
819 let buf = &frame.buffer;
820 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('║'));
821 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('║'));
822 assert!(
823 buf.get(1, 0).unwrap().is_empty()
824 || buf.get(1, 0).unwrap().content.as_char() == Some(' ')
825 );
826 }
827
828 #[test]
829 fn render_missing_left_keeps_horizontal_corner_logic() {
830 let block = Block::new()
831 .borders(Borders::TOP | Borders::RIGHT | Borders::BOTTOM)
832 .border_type(BorderType::Square);
833 let area = Rect::new(0, 0, 4, 3);
834 let mut pool = GraphemePool::new();
835 let mut frame = Frame::new(4, 3, &mut pool);
836 block.render(area, &mut frame);
837
838 let buf = &frame.buffer;
839 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('─'));
840 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('┐'));
841 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('─'));
842 assert_eq!(buf.get(3, 2).unwrap().content.as_char(), Some('┘'));
843 assert_eq!(buf.get(3, 1).unwrap().content.as_char(), Some('│'));
844 }
845
846 #[test]
847 fn render_title_left_aligned() {
848 let block = Block::new()
849 .borders(Borders::ALL)
850 .title("Test")
851 .title_alignment(Alignment::Left);
852 let area = Rect::new(0, 0, 10, 3);
853 let mut pool = GraphemePool::new();
854 let mut frame = Frame::new(10, 3, &mut pool);
855 block.render(area, &mut frame);
856
857 let buf = &frame.buffer;
858 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('T'));
859 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('e'));
860 }
861
862 #[test]
863 fn render_title_center_aligned() {
864 let block = Block::new()
865 .borders(Borders::ALL)
866 .title("Hi")
867 .title_alignment(Alignment::Center);
868 let area = Rect::new(0, 0, 10, 3);
869 let mut pool = GraphemePool::new();
870 let mut frame = Frame::new(10, 3, &mut pool);
871 block.render(area, &mut frame);
872
873 let buf = &frame.buffer;
875 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('H'));
876 assert_eq!(buf.get(5, 0).unwrap().content.as_char(), Some('i'));
877 }
878
879 #[test]
880 fn render_title_center_aligned_with_wide_grapheme() {
881 let block = Block::new()
882 .borders(Borders::ALL)
883 .title("界")
884 .title_alignment(Alignment::Center);
885 let area = Rect::new(0, 0, 8, 3);
886 let mut pool = GraphemePool::new();
887 let mut frame = Frame::new(8, 3, &mut pool);
888 block.render(area, &mut frame);
889
890 let buf = &frame.buffer;
892 let cell = buf.get(3, 0).unwrap();
893 assert!(
894 cell.content.as_char() == Some('界') || cell.content.is_grapheme(),
895 "expected title grapheme at x=3"
896 );
897 assert!(buf.get(4, 0).unwrap().is_continuation());
898 }
899
900 #[test]
901 fn render_title_right_aligned() {
902 let block = Block::new()
903 .borders(Borders::ALL)
904 .title("Hi")
905 .title_alignment(Alignment::Right);
906 let area = Rect::new(0, 0, 10, 3);
907 let mut pool = GraphemePool::new();
908 let mut frame = Frame::new(10, 3, &mut pool);
909 block.render(area, &mut frame);
910
911 let buf = &frame.buffer;
912 assert_eq!(buf.get(7, 0).unwrap().content.as_char(), Some('H'));
914 assert_eq!(buf.get(8, 0).unwrap().content.as_char(), Some('i'));
915 }
916
917 #[test]
918 fn render_title_right_aligned_truncated_wide_grapheme_uses_fitted_width() {
919 let block = Block::new()
920 .borders(Borders::ALL)
921 .title("界界")
922 .title_alignment(Alignment::Right);
923 let area = Rect::new(0, 0, 5, 3);
924 let mut pool = GraphemePool::new();
925 let mut frame = Frame::new(5, 3, &mut pool);
926 block.render(area, &mut frame);
927
928 let buf = &frame.buffer;
929 let cell = buf.get(2, 0).unwrap();
930 assert!(
931 cell.content.as_char() == Some('界') || cell.content.is_grapheme(),
932 "expected fitted wide title to be right aligned"
933 );
934 assert!(buf.get(3, 0).unwrap().is_continuation());
935 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('─'));
936 }
937
938 #[test]
939 fn render_multi_title_alignment_uses_last_title_and_alignment() {
940 let block = Block::new()
941 .borders(Borders::ALL)
942 .title("Left")
943 .title_alignment(Alignment::Left)
944 .title("Right")
945 .title_alignment(Alignment::Right);
946 let area = Rect::new(0, 0, 12, 3);
947 let mut pool = GraphemePool::new();
948 let mut frame = Frame::new(12, 3, &mut pool);
949 block.render(area, &mut frame);
950
951 let buf = &frame.buffer;
952 assert_eq!(buf.get(6, 0).unwrap().content.as_char(), Some('R'));
953 assert_ne!(buf.get(1, 0).unwrap().content.as_char(), Some('L'));
954 }
955
956 #[test]
957 fn title_not_rendered_without_top_border() {
958 let block = Block::new()
959 .borders(Borders::LEFT | Borders::RIGHT | Borders::BOTTOM)
960 .title("Hi");
961 let area = Rect::new(0, 0, 10, 3);
962 let mut pool = GraphemePool::new();
963 let mut frame = Frame::new(10, 3, &mut pool);
964 block.render(area, &mut frame);
965
966 let buf = &frame.buffer;
967 assert_ne!(buf.get(1, 0).unwrap().content.as_char(), Some('H'));
969 }
970
971 #[test]
972 fn border_style_applied() {
973 let block = Block::new()
974 .borders(Borders::ALL)
975 .border_style(Style::new().fg(PackedRgba::rgb(255, 0, 0)));
976 let area = Rect::new(0, 0, 5, 3);
977 let mut pool = GraphemePool::new();
978 let mut frame = Frame::new(5, 3, &mut pool);
979 block.render(area, &mut frame);
980
981 let buf = &frame.buffer;
982 assert_eq!(buf.get(0, 0).unwrap().fg, PackedRgba::rgb(255, 0, 0));
983 }
984
985 #[test]
986 fn only_horizontal_borders() {
987 let block = Block::new()
988 .borders(Borders::TOP | Borders::BOTTOM)
989 .border_type(BorderType::Square);
990 let area = Rect::new(0, 0, 5, 3);
991 let mut pool = GraphemePool::new();
992 let mut frame = Frame::new(5, 3, &mut pool);
993 block.render(area, &mut frame);
994
995 let buf = &frame.buffer;
996 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('─'));
998 assert_eq!(buf.get(2, 2).unwrap().content.as_char(), Some('─'));
999 assert!(
1001 buf.get(0, 1).unwrap().is_empty()
1002 || buf.get(0, 1).unwrap().content.as_char() == Some(' ')
1003 );
1004 }
1005
1006 #[test]
1007 fn degradation_simple_borders_forces_ascii() {
1008 use ftui_render::budget::DegradationLevel;
1009
1010 let block = Block::new()
1011 .borders(Borders::ALL)
1012 .border_type(BorderType::Rounded);
1013 let area = Rect::new(0, 0, 5, 3);
1014 let mut pool = GraphemePool::new();
1015 let mut frame = Frame::new(5, 3, &mut pool);
1016 frame.set_degradation(DegradationLevel::SimpleBorders);
1017 block.render(area, &mut frame);
1018
1019 let buf = &frame.buffer;
1020 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('+'));
1021 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('+'));
1022 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('-'));
1023 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('|'));
1024 }
1025
1026 #[test]
1027 fn degradation_simple_borders_partial_edges_use_ascii_corners() {
1028 use ftui_render::budget::DegradationLevel;
1029
1030 let block = Block::new()
1031 .borders(Borders::TOP | Borders::RIGHT | Borders::BOTTOM)
1032 .border_type(BorderType::Double);
1033 let area = Rect::new(0, 0, 4, 3);
1034 let mut pool = GraphemePool::new();
1035 let mut frame = Frame::new(4, 3, &mut pool);
1036 frame.set_degradation(DegradationLevel::SimpleBorders);
1037 block.render(area, &mut frame);
1038
1039 let buf = &frame.buffer;
1040 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('-'));
1041 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('+'));
1042 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('-'));
1043 assert_eq!(buf.get(3, 2).unwrap().content.as_char(), Some('+'));
1044 assert_eq!(buf.get(3, 1).unwrap().content.as_char(), Some('|'));
1045 }
1046
1047 #[test]
1048 fn degradation_no_styling_renders_title_without_styles() {
1049 use ftui_render::budget::DegradationLevel;
1050
1051 let block = Block::new()
1052 .borders(Borders::ALL)
1053 .border_style(Style::new().fg(PackedRgba::rgb(200, 0, 0)))
1054 .title("Hi");
1055 let area = Rect::new(0, 0, 6, 3);
1056 let mut pool = GraphemePool::new();
1057 let mut frame = Frame::new(6, 3, &mut pool);
1058 frame.set_degradation(DegradationLevel::NoStyling);
1059 block.render(area, &mut frame);
1060
1061 let buf = &frame.buffer;
1062 let default_fg = Cell::default().fg;
1063 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('H'));
1064 assert_eq!(buf.get(1, 0).unwrap().fg, default_fg);
1065 }
1066
1067 #[test]
1068 fn degradation_no_styling_keeps_border_when_title_does_not_fit() {
1069 use ftui_render::budget::DegradationLevel;
1070
1071 let titled = Block::new()
1072 .borders(Borders::ALL)
1073 .border_type(BorderType::Square)
1074 .title("界");
1075 let plain = Block::new()
1076 .borders(Borders::ALL)
1077 .border_type(BorderType::Square);
1078 let area = Rect::new(0, 0, 3, 3);
1079
1080 let mut titled_pool = GraphemePool::new();
1081 let mut titled_frame = Frame::new(3, 3, &mut titled_pool);
1082 titled_frame.set_degradation(DegradationLevel::NoStyling);
1083 titled.render(area, &mut titled_frame);
1084
1085 let mut plain_pool = GraphemePool::new();
1086 let mut plain_frame = Frame::new(3, 3, &mut plain_pool);
1087 plain_frame.set_degradation(DegradationLevel::NoStyling);
1088 plain.render(area, &mut plain_frame);
1089
1090 assert_eq!(titled_frame.buffer.get(1, 0), plain_frame.buffer.get(1, 0));
1091 }
1092
1093 #[test]
1094 fn degradation_no_styling_drops_border_style_everywhere() {
1095 use ftui_render::budget::DegradationLevel;
1096
1097 let block = Block::new()
1098 .borders(Borders::ALL)
1099 .border_style(Style::new().fg(PackedRgba::rgb(200, 0, 0)).bold());
1100 let area = Rect::new(0, 0, 5, 3);
1101 let mut pool = GraphemePool::new();
1102 let mut frame = Frame::new(5, 3, &mut pool);
1103 frame.set_degradation(DegradationLevel::NoStyling);
1104 block.render(area, &mut frame);
1105
1106 let border = frame.buffer.get(0, 0).unwrap();
1107 let default_cell = Cell::from_char(border.content.as_char().unwrap());
1108 assert_eq!(border.fg, default_cell.fg);
1109 assert_eq!(border.bg, default_cell.bg);
1110 assert_eq!(border.attrs, default_cell.attrs);
1111 }
1112
1113 #[test]
1114 fn degradation_essential_only_clears_stale_borders_and_title() {
1115 use ftui_render::budget::DegradationLevel;
1116
1117 let block = Block::bordered()
1118 .border_type(BorderType::Square)
1119 .title("Hi");
1120 let area = Rect::new(0, 0, 6, 3);
1121 let mut pool = GraphemePool::new();
1122 let mut frame = Frame::new(6, 3, &mut pool);
1123 block.render(area, &mut frame);
1124
1125 frame.set_degradation(DegradationLevel::EssentialOnly);
1126 block.render(area, &mut frame);
1127
1128 let buf = &frame.buffer;
1129 for y in 0..area.height {
1130 for x in 0..area.width {
1131 assert!(
1132 buf.get(x, y).unwrap().is_empty(),
1133 "expected cleared cell at ({x}, {y}), got {:?}",
1134 buf.get(x, y).unwrap()
1135 );
1136 }
1137 }
1138 }
1139
1140 #[test]
1141 fn degradation_skeleton_clears_area() {
1142 use ftui_render::budget::DegradationLevel;
1143
1144 let block = Block::bordered();
1145 let area = Rect::new(0, 0, 3, 2);
1146 let mut pool = GraphemePool::new();
1147 let mut frame = Frame::new(3, 2, &mut pool);
1148 frame.buffer.fill(area, Cell::from_char('X'));
1149 frame.set_degradation(DegradationLevel::Skeleton);
1150 block.render(area, &mut frame);
1151
1152 let buf = &frame.buffer;
1153 assert!(buf.get(0, 0).unwrap().is_empty());
1154 }
1155
1156 #[test]
1157 fn block_equality() {
1158 let a = Block::new().borders(Borders::ALL).title("Test");
1159 let b = Block::new().borders(Borders::ALL).title("Test");
1160 assert_eq!(a, b);
1161 }
1162
1163 #[test]
1164 fn render_1x1_no_panic() {
1165 let block = Block::bordered();
1166 let area = Rect::new(0, 0, 1, 1);
1167 let mut pool = GraphemePool::new();
1168 let mut frame = Frame::new(1, 1, &mut pool);
1169 block.render(area, &mut frame);
1170 }
1171
1172 #[test]
1173 fn render_2x2_with_borders() {
1174 let block = Block::bordered().border_type(BorderType::Square);
1175 let area = Rect::new(0, 0, 2, 2);
1176 let mut pool = GraphemePool::new();
1177 let mut frame = Frame::new(2, 2, &mut pool);
1178 block.render(area, &mut frame);
1179
1180 let buf = &frame.buffer;
1181 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('┌'));
1182 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('┐'));
1183 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('└'));
1184 assert_eq!(buf.get(1, 1).unwrap().content.as_char(), Some('┘'));
1185 }
1186
1187 #[test]
1188 fn title_too_narrow() {
1189 let block = Block::bordered().title("LongTitle");
1191 let area = Rect::new(0, 0, 4, 3);
1192 let mut pool = GraphemePool::new();
1193 let mut frame = Frame::new(4, 3, &mut pool);
1194 block.render(area, &mut frame);
1195 }
1197
1198 #[test]
1199 fn alignment_default_is_left() {
1200 assert_eq!(Alignment::default(), Alignment::Left);
1201 }
1202
1203 use crate::MeasurableWidget;
1206 use ftui_core::geometry::Size;
1207
1208 #[test]
1209 fn chrome_size_no_borders() {
1210 let block = Block::new();
1211 assert_eq!(block.chrome_size(), (0, 0));
1212 }
1213
1214 #[test]
1215 fn chrome_size_all_borders() {
1216 let block = Block::bordered();
1217 assert_eq!(block.chrome_size(), (4, 4));
1220 }
1221
1222 #[test]
1223 fn chrome_size_partial_borders() {
1224 let block = Block::new().borders(Borders::TOP | Borders::LEFT);
1225 assert_eq!(block.chrome_size(), (1, 1));
1226 }
1227
1228 #[test]
1229 fn chrome_size_horizontal_only() {
1230 let block = Block::new().borders(Borders::LEFT | Borders::RIGHT);
1231 assert_eq!(block.chrome_size(), (2, 0));
1232 }
1233
1234 #[test]
1235 fn chrome_size_vertical_only() {
1236 let block = Block::new().borders(Borders::TOP | Borders::BOTTOM);
1237 assert_eq!(block.chrome_size(), (0, 2));
1238 }
1239
1240 #[test]
1241 fn measure_no_borders() {
1242 let block = Block::new();
1243 let constraints = block.measure(Size::MAX);
1244 assert_eq!(constraints.min, Size::ZERO);
1245 assert_eq!(constraints.preferred, Size::ZERO);
1246 }
1247
1248 #[test]
1249 fn measure_all_borders() {
1250 let block = Block::bordered();
1251 let constraints = block.measure(Size::MAX);
1252 assert_eq!(constraints.min, Size::new(4, 4));
1253 assert_eq!(constraints.preferred, Size::new(4, 4));
1254 assert_eq!(constraints.max, None); }
1256
1257 #[test]
1258 fn measure_partial_borders() {
1259 let block = Block::new().borders(Borders::TOP | Borders::RIGHT);
1260 let constraints = block.measure(Size::MAX);
1261 assert_eq!(constraints.min, Size::new(1, 1));
1262 assert_eq!(constraints.preferred, Size::new(1, 1));
1263 }
1264
1265 #[test]
1266 fn has_intrinsic_size_with_borders() {
1267 let block = Block::bordered();
1268 assert!(block.has_intrinsic_size());
1269 }
1270
1271 #[test]
1272 fn has_no_intrinsic_size_without_borders() {
1273 let block = Block::new();
1274 assert!(!block.has_intrinsic_size());
1275 }
1276
1277 #[test]
1278 fn measure_is_pure() {
1279 let block = Block::bordered();
1280 let a = block.measure(Size::new(100, 50));
1281 let b = block.measure(Size::new(100, 50));
1282 assert_eq!(a, b);
1283 }
1284
1285 #[test]
1286 fn block_styled_reads_sheet() {
1287 let sheet = StyleSheet::new();
1288 let blue = ftui_render::cell::PackedRgba::rgb(0, 100, 255);
1289 sheet.define("heading", Style::new().bold().fg(blue));
1290
1291 let block = Block::styled(&sheet, "heading")
1292 .borders(Borders::ALL)
1293 .title("T");
1294 let area = Rect::new(0, 0, 8, 3);
1295 let mut pool = GraphemePool::new();
1296 let mut frame = Frame::new(8, 3, &mut pool);
1297 block.render(area, &mut frame);
1298
1299 let title_cell = frame.buffer.get(1, 0).unwrap();
1301 assert_eq!(title_cell.fg, blue);
1302 assert!(
1303 title_cell
1304 .attrs
1305 .has_flag(ftui_render::cell::StyleFlags::BOLD)
1306 );
1307
1308 let border_cell = frame.buffer.get(0, 0).unwrap();
1310 assert_eq!(border_cell.fg, blue);
1311 }
1312
1313 #[test]
1314 fn redefine_style_then_rebuild_propagates() {
1315 let sheet = StyleSheet::new();
1316 let blue = ftui_render::cell::PackedRgba::rgb(0, 100, 255);
1317 let red = ftui_render::cell::PackedRgba::rgb(255, 0, 0);
1318
1319 sheet.define("heading", Style::new().bold().fg(blue));
1320 let block1 = Block::styled(&sheet, "heading")
1321 .borders(Borders::ALL)
1322 .title("T");
1323 let area = Rect::new(0, 0, 8, 3);
1324 let mut pool1 = GraphemePool::new();
1325 let mut frame1 = Frame::new(8, 3, &mut pool1);
1326 block1.render(area, &mut frame1);
1327 assert_eq!(frame1.buffer.get(1, 0).unwrap().fg, blue);
1328 assert!(
1329 frame1
1330 .buffer
1331 .get(1, 0)
1332 .unwrap()
1333 .attrs
1334 .has_flag(ftui_render::cell::StyleFlags::BOLD)
1335 );
1336
1337 sheet.define("heading", Style::new().fg(red));
1339 let block2 = Block::styled(&sheet, "heading")
1340 .borders(Borders::ALL)
1341 .title("T");
1342 let mut pool2 = GraphemePool::new();
1343 let mut frame2 = Frame::new(8, 3, &mut pool2);
1344 block2.render(area, &mut frame2);
1345 assert_eq!(frame2.buffer.get(1, 0).unwrap().fg, red);
1346 assert!(
1347 !frame2
1348 .buffer
1349 .get(1, 0)
1350 .unwrap()
1351 .attrs
1352 .has_flag(ftui_render::cell::StyleFlags::BOLD)
1353 );
1354 }
1355
1356 #[test]
1357 fn missing_name_falls_back_to_default() {
1358 let sheet = StyleSheet::new();
1359 let block_styled = Block::styled(&sheet, "nope");
1360 let block_default = Block::default();
1361
1362 let area = Rect::new(0, 0, 10, 5);
1363 let mut pool1 = GraphemePool::new();
1364 let mut frame1 = Frame::new(10, 5, &mut pool1);
1365 block_styled.render(area, &mut frame1);
1366
1367 let mut pool2 = GraphemePool::new();
1368 let mut frame2 = Frame::new(10, 5, &mut pool2);
1369 block_default.render(area, &mut frame2);
1370
1371 assert_eq!(frame1.buffer, frame2.buffer);
1372 }
1373
1374 #[test]
1375 fn compose_precedence_name_then_border() {
1376 let sheet = StyleSheet::new();
1377 let blue = ftui_render::cell::PackedRgba::rgb(0, 100, 255);
1378 let green = ftui_render::cell::PackedRgba::rgb(0, 255, 100);
1379
1380 sheet.define("heading", Style::new().fg(blue));
1381 sheet.define("heading.border", Style::new().fg(green));
1382
1383 let block = Block::styled(&sheet, "heading")
1384 .borders(Borders::ALL)
1385 .title("T");
1386 let area = Rect::new(0, 0, 8, 3);
1387 let mut pool = GraphemePool::new();
1388 let mut frame = Frame::new(8, 3, &mut pool);
1389 block.render(area, &mut frame);
1390
1391 assert_eq!(frame.buffer.get(1, 1).unwrap().fg, blue);
1393 assert_eq!(frame.buffer.get(0, 0).unwrap().fg, green);
1395 assert_eq!(frame.buffer.get(1, 0).unwrap().fg, green);
1397 }
1398
1399 #[test]
1400 fn explicit_style_overrides_sheet() {
1401 let sheet = StyleSheet::new();
1402 let blue = ftui_render::cell::PackedRgba::rgb(0, 100, 255);
1403 let red = ftui_render::cell::PackedRgba::rgb(255, 0, 0);
1404
1405 sheet.define("heading", Style::new().fg(blue));
1406 let block = Block::styled(&sheet, "heading")
1407 .borders(Borders::ALL)
1408 .title("T")
1409 .style(Style::new().fg(red));
1410
1411 let area = Rect::new(0, 0, 8, 3);
1412 let mut pool = GraphemePool::new();
1413 let mut frame = Frame::new(8, 3, &mut pool);
1414 block.render(area, &mut frame);
1415
1416 assert_eq!(frame.buffer.get(1, 1).unwrap().fg, red);
1418 assert_eq!(frame.buffer.get(0, 0).unwrap().fg, blue);
1420 }
1421
1422 use proptest::prelude::*;
1423
1424 proptest! {
1425 #[test]
1426 fn prop_styled_block_equals_manual_block(
1427 fg_r in 0u8..255, fg_g in 0u8..255, fg_b in 0u8..255,
1428 border_r in 0u8..255, border_g in 0u8..255, border_b in 0u8..255,
1429 ) {
1430 let s = Style::new().fg(ftui_render::cell::PackedRgba::rgb(fg_r, fg_g, fg_b));
1431 let b = Style::new().fg(ftui_render::cell::PackedRgba::rgb(border_r, border_g, border_b));
1432
1433 let sheet = StyleSheet::new();
1434 sheet.define("card", s);
1435 sheet.define("card.border", b);
1436
1437 let styled = Block::styled(&sheet, "card").borders(Borders::ALL).title("Hi");
1438 let manual = Block::default()
1439 .style(s)
1440 .border_style(sheet.compose(&["card", "card.border"]))
1441 .borders(Borders::ALL)
1442 .title("Hi");
1443
1444 let area = Rect::new(0, 0, 10, 4);
1445 let mut pool1 = GraphemePool::new();
1446 let mut frame1 = Frame::new(10, 4, &mut pool1);
1447 styled.render(area, &mut frame1);
1448
1449 let mut pool2 = GraphemePool::new();
1450 let mut frame2 = Frame::new(10, 4, &mut pool2);
1451 manual.render(area, &mut frame2);
1452
1453 prop_assert_eq!(frame1.buffer, frame2.buffer);
1454 }
1455 }
1456}