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
343impl Widget for Block<'_> {
344 fn render(&self, area: Rect, frame: &mut Frame) {
345 #[cfg(feature = "tracing")]
346 let _span = tracing::debug_span!(
347 "widget_render",
348 widget = "Block",
349 x = area.x,
350 y = area.y,
351 w = area.width,
352 h = area.height
353 )
354 .entered();
355
356 if area.is_empty() {
357 return;
358 }
359
360 if frame.a11y_enabled() {
368 frame.push_a11y_nodes(ftui_a11y::Accessible::accessibility_nodes(self, area));
369 }
370
371 let deg = frame.degradation;
372 let border_style = if deg.apply_styling() {
373 self.border_style
374 } else {
375 Style::default()
376 };
377
378 if !deg.render_content() {
380 frame.buffer.fill(area, Cell::default());
381 return;
382 }
383
384 if !deg.render_decorative() {
387 frame.buffer.fill(area, Cell::default());
388 if deg.apply_styling() {
389 set_style_area(&mut frame.buffer, area, self.style);
390 }
391 return;
392 }
393
394 if deg.apply_styling() {
396 set_style_area(&mut frame.buffer, area, self.style);
397 }
398
399 if deg.use_unicode_borders() {
401 self.render_borders(area, &mut frame.buffer, border_style);
402 } else {
403 self.render_borders_ascii(area, &mut frame.buffer, border_style);
405 }
406
407 if deg.apply_styling() {
409 self.render_title(area, frame);
410 } else if deg.render_decorative() {
411 if let Some(title) = self.title
414 && self.borders.contains(Borders::TOP)
415 && area.width >= 3
416 {
417 let available_width = area.width.saturating_sub(2) as usize;
418 if available_width > 0 {
419 let display_width = fitted_text_width(title, available_width);
420 if display_width == 0 {
421 return;
422 }
423 let x = match self.title_alignment {
424 Alignment::Left => area.x.saturating_add(1),
425 Alignment::Center => area.x.saturating_add(1).saturating_add(
426 ((available_width.saturating_sub(display_width)) / 2) as u16,
427 ),
428 Alignment::Right => area
429 .right()
430 .saturating_sub(1)
431 .saturating_sub(display_width as u16),
432 };
433 let max_x = area.right().saturating_sub(1);
434 frame.buffer.fill(
437 Rect::new(x, area.y, display_width as u16, 1),
438 Cell::default(),
439 );
440 draw_text_span(frame, x, area.y, title, Style::default(), max_x);
441 }
442 }
443 }
444 }
445}
446
447impl MeasurableWidget for Block<'_> {
448 fn measure(&self, _available: Size) -> SizeConstraints {
449 let (chrome_width, chrome_height) = self.chrome_size();
450 let chrome = Size::new(chrome_width, chrome_height);
451
452 SizeConstraints::at_least(chrome, chrome)
457 }
458
459 fn has_intrinsic_size(&self) -> bool {
460 self.borders != Borders::empty()
462 }
463}
464
465fn fitted_text_width(text: &str, max_width: usize) -> usize {
466 let mut width = 0usize;
467 for grapheme in graphemes(text) {
468 let w = grapheme_width(grapheme);
469 if w == 0 {
470 continue;
471 }
472 if width.saturating_add(w) > max_width {
473 break;
474 }
475 width += w;
476 }
477 width
478}
479
480impl ftui_a11y::Accessible for Block<'_> {
485 fn accessibility_nodes(&self, area: Rect) -> Vec<ftui_a11y::node::A11yNodeInfo> {
486 use ftui_a11y::node::{A11yNodeInfo, A11yRole};
487
488 let id = crate::a11y_node_id(area);
489 let mut node = A11yNodeInfo::new(id, A11yRole::Group, area);
490 if let Some(title) = self.title_text() {
491 node = node.with_name(title);
492 }
493 vec![node]
494 }
495}
496
497#[cfg(test)]
498mod tests {
499 use super::*;
500 use crate::borders::BorderSet;
501 use ftui_render::cell::PackedRgba;
502 use ftui_render::grapheme_pool::GraphemePool;
503
504 #[test]
505 fn inner_with_all_borders() {
506 let block = Block::new().borders(Borders::ALL);
507 let area = Rect::new(0, 0, 10, 10);
508 let inner = block.inner(area);
509 assert_eq!(inner, Rect::new(1, 1, 8, 8));
510 }
511
512 #[test]
513 fn inner_with_no_borders() {
514 let block = Block::new();
515 let area = Rect::new(0, 0, 10, 10);
516 let inner = block.inner(area);
517 assert_eq!(inner, area);
518 }
519
520 #[test]
521 fn inner_with_partial_borders() {
522 let block = Block::new().borders(Borders::TOP | Borders::LEFT);
523 let area = Rect::new(0, 0, 10, 10);
524 let inner = block.inner(area);
525 assert_eq!(inner, Rect::new(1, 1, 9, 9));
526 }
527
528 #[test]
529 fn render_empty_area() {
530 let block = Block::new().borders(Borders::ALL);
531 let area = Rect::new(0, 0, 0, 0);
532 let mut pool = GraphemePool::new();
533 let mut frame = Frame::new(1, 1, &mut pool);
534 block.render(area, &mut frame);
535 }
536
537 #[test]
538 fn render_block_with_square_borders() {
539 let block = Block::new()
540 .borders(Borders::ALL)
541 .border_type(BorderType::Square);
542 let area = Rect::new(0, 0, 5, 3);
543 let mut pool = GraphemePool::new();
544 let mut frame = Frame::new(5, 3, &mut pool);
545 block.render(area, &mut frame);
546
547 let buf = &frame.buffer;
548 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('┌'));
549 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('┐'));
550 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('└'));
551 assert_eq!(buf.get(4, 2).unwrap().content.as_char(), Some('┘'));
552 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('─'));
553 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('│'));
554 }
555
556 #[test]
557 fn render_block_with_dashed_borders() {
558 let block = Block::bordered().border_type(BorderType::Dashed);
559 let area = Rect::new(0, 0, 10, 3);
560 let mut pool = GraphemePool::new();
561 let mut frame = Frame::new(10, 3, &mut pool);
562 block.render(area, &mut frame);
563
564 let buf = &frame.buffer;
565 let top: String = (0..10)
566 .map(|x| buf.get(x, 0).unwrap().content.as_char().unwrap_or(' '))
567 .collect();
568 assert_eq!(top, "┌┄┄┄┄┄┄┄┄┐");
569 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('┆'));
571 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('└'));
572 assert_eq!(buf.get(9, 2).unwrap().content.as_char(), Some('┘'));
573 }
574
575 #[test]
576 fn block_dashed_renders_top_row() {
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 row0: String = (0..10)
585 .map(|x| buf.get(x, 0).unwrap().content.as_char().unwrap_or(' '))
586 .collect();
587 assert_eq!(row0, "┌┄┄┄┄┄┄┄┄┐");
588 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('┆'));
589 assert_eq!(buf.get(9, 1).unwrap().content.as_char(), Some('┆'));
590 let row2: String = (0..10)
591 .map(|x| buf.get(x, 2).unwrap().content.as_char().unwrap_or(' '))
592 .collect();
593 assert_eq!(row2, "└┄┄┄┄┄┄┄┄┘");
594 }
595
596 #[test]
597 fn block_custom_ascii_renders() {
598 let custom = BorderSet {
599 top_left: '#',
600 horizontal: '-',
601 top_right: '#',
602 vertical: '|',
603 bottom_left: '#',
604 bottom_right: '#',
605 tee_up: '+',
606 tee_down: '+',
607 tee_left: '+',
608 tee_right: '+',
609 cross: '+',
610 };
611 let block = Block::bordered().border_type(BorderType::Custom(custom));
612 let area = Rect::new(0, 0, 6, 3);
613 let mut pool = GraphemePool::new();
614 let mut frame = Frame::new(6, 3, &mut pool);
615 block.render(area, &mut frame);
616
617 let buf = &frame.buffer;
618 let row0: String = (0..6)
619 .map(|x| buf.get(x, 0).unwrap().content.as_char().unwrap_or(' '))
620 .collect();
621 assert_eq!(row0, "#----#");
622 }
623
624 #[test]
625 fn block_dashed_partial_borders() {
626 let block = Block::new()
627 .borders(Borders::TOP | Borders::BOTTOM)
628 .border_type(BorderType::Dashed);
629 let area = Rect::new(0, 0, 8, 3);
630 let mut pool = GraphemePool::new();
631 let mut frame = Frame::new(8, 3, &mut pool);
632 block.render(area, &mut frame);
633
634 let buf = &frame.buffer;
635 for y in 0..3 {
636 for x in 0..8 {
637 assert_ne!(
638 buf.get(x, y).unwrap().content.as_char(),
639 Some('┆'),
640 "cell ({x}, {y}) should not have vertical border"
641 );
642 }
643 }
644 let top: String = (0..8)
645 .map(|x| buf.get(x, 0).unwrap().content.as_char().unwrap_or(' '))
646 .collect();
647 let bottom: String = (0..8)
648 .map(|x| buf.get(x, 2).unwrap().content.as_char().unwrap_or(' '))
649 .collect();
650 assert_eq!(top, "┄┄┄┄┄┄┄┄");
651 assert_eq!(bottom, "┄┄┄┄┄┄┄┄");
652 }
653
654 #[test]
655 fn render_block_with_title() {
656 let block = Block::new()
657 .borders(Borders::ALL)
658 .border_type(BorderType::Square)
659 .title("Hi");
660 let area = Rect::new(0, 0, 10, 3);
661 let mut pool = GraphemePool::new();
662 let mut frame = Frame::new(10, 3, &mut pool);
663 block.render(area, &mut frame);
664
665 let buf = &frame.buffer;
666 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('H'));
667 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('i'));
668 }
669
670 #[test]
671 fn render_title_overrides_on_multiple_calls() {
672 let block = Block::new()
673 .borders(Borders::ALL)
674 .border_type(BorderType::Square)
675 .title("First")
676 .title("Second");
677 let area = Rect::new(0, 0, 12, 3);
678 let mut pool = GraphemePool::new();
679 let mut frame = Frame::new(12, 3, &mut pool);
680 block.render(area, &mut frame);
681
682 let buf = &frame.buffer;
683 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('S'));
684 }
685
686 #[test]
687 fn render_block_with_background() {
688 let block = Block::new().style(Style::new().bg(PackedRgba::rgb(10, 20, 30)));
689 let area = Rect::new(0, 0, 3, 2);
690 let mut pool = GraphemePool::new();
691 let mut frame = Frame::new(3, 2, &mut pool);
692 block.render(area, &mut frame);
693
694 let buf = &frame.buffer;
695 assert_eq!(buf.get(0, 0).unwrap().bg, PackedRgba::rgb(10, 20, 30));
696 assert_eq!(buf.get(2, 1).unwrap().bg, PackedRgba::rgb(10, 20, 30));
697 }
698
699 #[test]
700 fn inner_with_only_bottom() {
701 let block = Block::new().borders(Borders::BOTTOM);
702 let area = Rect::new(0, 0, 10, 10);
703 let inner = block.inner(area);
704 assert_eq!(inner, Rect::new(0, 0, 10, 9));
705 }
706
707 #[test]
708 fn inner_with_only_right() {
709 let block = Block::new().borders(Borders::RIGHT);
710 let area = Rect::new(0, 0, 10, 10);
711 let inner = block.inner(area);
712 assert_eq!(inner, Rect::new(0, 0, 9, 10));
713 }
714
715 #[test]
716 fn inner_saturates_on_tiny_area() {
717 let block = Block::new().borders(Borders::ALL);
718 let area = Rect::new(0, 0, 1, 1);
719 let inner = block.inner(area);
720 assert_eq!(inner.width, 0);
722 }
723
724 #[test]
725 fn bordered_constructor() {
726 let block = Block::bordered();
727 assert_eq!(block.borders, Borders::ALL);
728 }
729
730 #[test]
731 fn default_has_no_borders() {
732 let block = Block::new();
733 assert_eq!(block.borders, Borders::empty());
734 assert!(block.title.is_none());
735 }
736
737 #[test]
738 fn render_rounded_borders() {
739 let block = Block::new()
740 .borders(Borders::ALL)
741 .border_type(BorderType::Rounded);
742 let area = Rect::new(0, 0, 5, 3);
743 let mut pool = GraphemePool::new();
744 let mut frame = Frame::new(5, 3, &mut pool);
745 block.render(area, &mut frame);
746
747 let buf = &frame.buffer;
748 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('╭'));
749 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('╮'));
750 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('╰'));
751 assert_eq!(buf.get(4, 2).unwrap().content.as_char(), Some('╯'));
752 }
753
754 #[test]
755 fn render_double_borders() {
756 let block = Block::new()
757 .borders(Borders::ALL)
758 .border_type(BorderType::Double);
759 let area = Rect::new(0, 0, 5, 3);
760 let mut pool = GraphemePool::new();
761 let mut frame = Frame::new(5, 3, &mut pool);
762 block.render(area, &mut frame);
763
764 let buf = &frame.buffer;
765 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('╔'));
766 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('╗'));
767 }
768
769 #[test]
770 fn render_partial_borders_corners_only_when_edges_enabled() {
771 let block = Block::new()
772 .borders(Borders::TOP | Borders::LEFT | Borders::BOTTOM)
773 .border_type(BorderType::Square);
774 let area = Rect::new(0, 0, 4, 3);
775 let mut pool = GraphemePool::new();
776 let mut frame = Frame::new(4, 3, &mut pool);
777 block.render(area, &mut frame);
778
779 let buf = &frame.buffer;
780 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('┌'));
781 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('└'));
782 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('─'));
783 assert_eq!(buf.get(3, 2).unwrap().content.as_char(), Some('─'));
784 assert!(
785 buf.get(3, 1).unwrap().is_empty()
786 || buf.get(3, 1).unwrap().content.as_char() == Some(' ')
787 );
788 }
789
790 #[test]
791 fn render_vertical_only_borders_use_vertical_glyphs() {
792 let block = Block::new()
793 .borders(Borders::LEFT | Borders::RIGHT)
794 .border_type(BorderType::Double);
795 let area = Rect::new(0, 0, 4, 3);
796 let mut pool = GraphemePool::new();
797 let mut frame = Frame::new(4, 3, &mut pool);
798 block.render(area, &mut frame);
799
800 let buf = &frame.buffer;
801 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('║'));
802 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('║'));
803 assert!(
804 buf.get(1, 0).unwrap().is_empty()
805 || buf.get(1, 0).unwrap().content.as_char() == Some(' ')
806 );
807 }
808
809 #[test]
810 fn render_missing_left_keeps_horizontal_corner_logic() {
811 let block = Block::new()
812 .borders(Borders::TOP | Borders::RIGHT | Borders::BOTTOM)
813 .border_type(BorderType::Square);
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_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('─'));
823 assert_eq!(buf.get(3, 2).unwrap().content.as_char(), Some('┘'));
824 assert_eq!(buf.get(3, 1).unwrap().content.as_char(), Some('│'));
825 }
826
827 #[test]
828 fn render_title_left_aligned() {
829 let block = Block::new()
830 .borders(Borders::ALL)
831 .title("Test")
832 .title_alignment(Alignment::Left);
833 let area = Rect::new(0, 0, 10, 3);
834 let mut pool = GraphemePool::new();
835 let mut frame = Frame::new(10, 3, &mut pool);
836 block.render(area, &mut frame);
837
838 let buf = &frame.buffer;
839 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('T'));
840 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('e'));
841 }
842
843 #[test]
844 fn render_title_center_aligned() {
845 let block = Block::new()
846 .borders(Borders::ALL)
847 .title("Hi")
848 .title_alignment(Alignment::Center);
849 let area = Rect::new(0, 0, 10, 3);
850 let mut pool = GraphemePool::new();
851 let mut frame = Frame::new(10, 3, &mut pool);
852 block.render(area, &mut frame);
853
854 let buf = &frame.buffer;
856 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('H'));
857 assert_eq!(buf.get(5, 0).unwrap().content.as_char(), Some('i'));
858 }
859
860 #[test]
861 fn render_title_center_aligned_with_wide_grapheme() {
862 let block = Block::new()
863 .borders(Borders::ALL)
864 .title("界")
865 .title_alignment(Alignment::Center);
866 let area = Rect::new(0, 0, 8, 3);
867 let mut pool = GraphemePool::new();
868 let mut frame = Frame::new(8, 3, &mut pool);
869 block.render(area, &mut frame);
870
871 let buf = &frame.buffer;
873 let cell = buf.get(3, 0).unwrap();
874 assert!(
875 cell.content.as_char() == Some('界') || cell.content.is_grapheme(),
876 "expected title grapheme at x=3"
877 );
878 assert!(buf.get(4, 0).unwrap().is_continuation());
879 }
880
881 #[test]
882 fn render_title_right_aligned() {
883 let block = Block::new()
884 .borders(Borders::ALL)
885 .title("Hi")
886 .title_alignment(Alignment::Right);
887 let area = Rect::new(0, 0, 10, 3);
888 let mut pool = GraphemePool::new();
889 let mut frame = Frame::new(10, 3, &mut pool);
890 block.render(area, &mut frame);
891
892 let buf = &frame.buffer;
893 assert_eq!(buf.get(7, 0).unwrap().content.as_char(), Some('H'));
895 assert_eq!(buf.get(8, 0).unwrap().content.as_char(), Some('i'));
896 }
897
898 #[test]
899 fn render_title_right_aligned_truncated_wide_grapheme_uses_fitted_width() {
900 let block = Block::new()
901 .borders(Borders::ALL)
902 .title("界界")
903 .title_alignment(Alignment::Right);
904 let area = Rect::new(0, 0, 5, 3);
905 let mut pool = GraphemePool::new();
906 let mut frame = Frame::new(5, 3, &mut pool);
907 block.render(area, &mut frame);
908
909 let buf = &frame.buffer;
910 let cell = buf.get(2, 0).unwrap();
911 assert!(
912 cell.content.as_char() == Some('界') || cell.content.is_grapheme(),
913 "expected fitted wide title to be right aligned"
914 );
915 assert!(buf.get(3, 0).unwrap().is_continuation());
916 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('─'));
917 }
918
919 #[test]
920 fn render_multi_title_alignment_uses_last_title_and_alignment() {
921 let block = Block::new()
922 .borders(Borders::ALL)
923 .title("Left")
924 .title_alignment(Alignment::Left)
925 .title("Right")
926 .title_alignment(Alignment::Right);
927 let area = Rect::new(0, 0, 12, 3);
928 let mut pool = GraphemePool::new();
929 let mut frame = Frame::new(12, 3, &mut pool);
930 block.render(area, &mut frame);
931
932 let buf = &frame.buffer;
933 assert_eq!(buf.get(6, 0).unwrap().content.as_char(), Some('R'));
934 assert_ne!(buf.get(1, 0).unwrap().content.as_char(), Some('L'));
935 }
936
937 #[test]
938 fn title_not_rendered_without_top_border() {
939 let block = Block::new()
940 .borders(Borders::LEFT | Borders::RIGHT | Borders::BOTTOM)
941 .title("Hi");
942 let area = Rect::new(0, 0, 10, 3);
943 let mut pool = GraphemePool::new();
944 let mut frame = Frame::new(10, 3, &mut pool);
945 block.render(area, &mut frame);
946
947 let buf = &frame.buffer;
948 assert_ne!(buf.get(1, 0).unwrap().content.as_char(), Some('H'));
950 }
951
952 #[test]
953 fn border_style_applied() {
954 let block = Block::new()
955 .borders(Borders::ALL)
956 .border_style(Style::new().fg(PackedRgba::rgb(255, 0, 0)));
957 let area = Rect::new(0, 0, 5, 3);
958 let mut pool = GraphemePool::new();
959 let mut frame = Frame::new(5, 3, &mut pool);
960 block.render(area, &mut frame);
961
962 let buf = &frame.buffer;
963 assert_eq!(buf.get(0, 0).unwrap().fg, PackedRgba::rgb(255, 0, 0));
964 }
965
966 #[test]
967 fn only_horizontal_borders() {
968 let block = Block::new()
969 .borders(Borders::TOP | Borders::BOTTOM)
970 .border_type(BorderType::Square);
971 let area = Rect::new(0, 0, 5, 3);
972 let mut pool = GraphemePool::new();
973 let mut frame = Frame::new(5, 3, &mut pool);
974 block.render(area, &mut frame);
975
976 let buf = &frame.buffer;
977 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('─'));
979 assert_eq!(buf.get(2, 2).unwrap().content.as_char(), Some('─'));
980 assert!(
982 buf.get(0, 1).unwrap().is_empty()
983 || buf.get(0, 1).unwrap().content.as_char() == Some(' ')
984 );
985 }
986
987 #[test]
988 fn degradation_simple_borders_forces_ascii() {
989 use ftui_render::budget::DegradationLevel;
990
991 let block = Block::new()
992 .borders(Borders::ALL)
993 .border_type(BorderType::Rounded);
994 let area = Rect::new(0, 0, 5, 3);
995 let mut pool = GraphemePool::new();
996 let mut frame = Frame::new(5, 3, &mut pool);
997 frame.set_degradation(DegradationLevel::SimpleBorders);
998 block.render(area, &mut frame);
999
1000 let buf = &frame.buffer;
1001 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('+'));
1002 assert_eq!(buf.get(4, 0).unwrap().content.as_char(), Some('+'));
1003 assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('-'));
1004 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('|'));
1005 }
1006
1007 #[test]
1008 fn degradation_simple_borders_partial_edges_use_ascii_corners() {
1009 use ftui_render::budget::DegradationLevel;
1010
1011 let block = Block::new()
1012 .borders(Borders::TOP | Borders::RIGHT | Borders::BOTTOM)
1013 .border_type(BorderType::Double);
1014 let area = Rect::new(0, 0, 4, 3);
1015 let mut pool = GraphemePool::new();
1016 let mut frame = Frame::new(4, 3, &mut pool);
1017 frame.set_degradation(DegradationLevel::SimpleBorders);
1018 block.render(area, &mut frame);
1019
1020 let buf = &frame.buffer;
1021 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('-'));
1022 assert_eq!(buf.get(3, 0).unwrap().content.as_char(), Some('+'));
1023 assert_eq!(buf.get(0, 2).unwrap().content.as_char(), Some('-'));
1024 assert_eq!(buf.get(3, 2).unwrap().content.as_char(), Some('+'));
1025 assert_eq!(buf.get(3, 1).unwrap().content.as_char(), Some('|'));
1026 }
1027
1028 #[test]
1029 fn degradation_no_styling_renders_title_without_styles() {
1030 use ftui_render::budget::DegradationLevel;
1031
1032 let block = Block::new()
1033 .borders(Borders::ALL)
1034 .border_style(Style::new().fg(PackedRgba::rgb(200, 0, 0)))
1035 .title("Hi");
1036 let area = Rect::new(0, 0, 6, 3);
1037 let mut pool = GraphemePool::new();
1038 let mut frame = Frame::new(6, 3, &mut pool);
1039 frame.set_degradation(DegradationLevel::NoStyling);
1040 block.render(area, &mut frame);
1041
1042 let buf = &frame.buffer;
1043 let default_fg = Cell::default().fg;
1044 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('H'));
1045 assert_eq!(buf.get(1, 0).unwrap().fg, default_fg);
1046 }
1047
1048 #[test]
1049 fn degradation_no_styling_keeps_border_when_title_does_not_fit() {
1050 use ftui_render::budget::DegradationLevel;
1051
1052 let titled = Block::new()
1053 .borders(Borders::ALL)
1054 .border_type(BorderType::Square)
1055 .title("界");
1056 let plain = Block::new()
1057 .borders(Borders::ALL)
1058 .border_type(BorderType::Square);
1059 let area = Rect::new(0, 0, 3, 3);
1060
1061 let mut titled_pool = GraphemePool::new();
1062 let mut titled_frame = Frame::new(3, 3, &mut titled_pool);
1063 titled_frame.set_degradation(DegradationLevel::NoStyling);
1064 titled.render(area, &mut titled_frame);
1065
1066 let mut plain_pool = GraphemePool::new();
1067 let mut plain_frame = Frame::new(3, 3, &mut plain_pool);
1068 plain_frame.set_degradation(DegradationLevel::NoStyling);
1069 plain.render(area, &mut plain_frame);
1070
1071 assert_eq!(titled_frame.buffer.get(1, 0), plain_frame.buffer.get(1, 0));
1072 }
1073
1074 #[test]
1075 fn degradation_no_styling_drops_border_style_everywhere() {
1076 use ftui_render::budget::DegradationLevel;
1077
1078 let block = Block::new()
1079 .borders(Borders::ALL)
1080 .border_style(Style::new().fg(PackedRgba::rgb(200, 0, 0)).bold());
1081 let area = Rect::new(0, 0, 5, 3);
1082 let mut pool = GraphemePool::new();
1083 let mut frame = Frame::new(5, 3, &mut pool);
1084 frame.set_degradation(DegradationLevel::NoStyling);
1085 block.render(area, &mut frame);
1086
1087 let border = frame.buffer.get(0, 0).unwrap();
1088 let default_cell = Cell::from_char(border.content.as_char().unwrap());
1089 assert_eq!(border.fg, default_cell.fg);
1090 assert_eq!(border.bg, default_cell.bg);
1091 assert_eq!(border.attrs, default_cell.attrs);
1092 }
1093
1094 #[test]
1095 fn degradation_essential_only_clears_stale_borders_and_title() {
1096 use ftui_render::budget::DegradationLevel;
1097
1098 let block = Block::bordered()
1099 .border_type(BorderType::Square)
1100 .title("Hi");
1101 let area = Rect::new(0, 0, 6, 3);
1102 let mut pool = GraphemePool::new();
1103 let mut frame = Frame::new(6, 3, &mut pool);
1104 block.render(area, &mut frame);
1105
1106 frame.set_degradation(DegradationLevel::EssentialOnly);
1107 block.render(area, &mut frame);
1108
1109 let buf = &frame.buffer;
1110 for y in 0..area.height {
1111 for x in 0..area.width {
1112 assert!(
1113 buf.get(x, y).unwrap().is_empty(),
1114 "expected cleared cell at ({x}, {y}), got {:?}",
1115 buf.get(x, y).unwrap()
1116 );
1117 }
1118 }
1119 }
1120
1121 #[test]
1122 fn degradation_skeleton_clears_area() {
1123 use ftui_render::budget::DegradationLevel;
1124
1125 let block = Block::bordered();
1126 let area = Rect::new(0, 0, 3, 2);
1127 let mut pool = GraphemePool::new();
1128 let mut frame = Frame::new(3, 2, &mut pool);
1129 frame.buffer.fill(area, Cell::from_char('X'));
1130 frame.set_degradation(DegradationLevel::Skeleton);
1131 block.render(area, &mut frame);
1132
1133 let buf = &frame.buffer;
1134 assert!(buf.get(0, 0).unwrap().is_empty());
1135 }
1136
1137 #[test]
1138 fn block_equality() {
1139 let a = Block::new().borders(Borders::ALL).title("Test");
1140 let b = Block::new().borders(Borders::ALL).title("Test");
1141 assert_eq!(a, b);
1142 }
1143
1144 #[test]
1145 fn render_1x1_no_panic() {
1146 let block = Block::bordered();
1147 let area = Rect::new(0, 0, 1, 1);
1148 let mut pool = GraphemePool::new();
1149 let mut frame = Frame::new(1, 1, &mut pool);
1150 block.render(area, &mut frame);
1151 }
1152
1153 #[test]
1154 fn render_2x2_with_borders() {
1155 let block = Block::bordered().border_type(BorderType::Square);
1156 let area = Rect::new(0, 0, 2, 2);
1157 let mut pool = GraphemePool::new();
1158 let mut frame = Frame::new(2, 2, &mut pool);
1159 block.render(area, &mut frame);
1160
1161 let buf = &frame.buffer;
1162 assert_eq!(buf.get(0, 0).unwrap().content.as_char(), Some('┌'));
1163 assert_eq!(buf.get(1, 0).unwrap().content.as_char(), Some('┐'));
1164 assert_eq!(buf.get(0, 1).unwrap().content.as_char(), Some('└'));
1165 assert_eq!(buf.get(1, 1).unwrap().content.as_char(), Some('┘'));
1166 }
1167
1168 #[test]
1169 fn title_too_narrow() {
1170 let block = Block::bordered().title("LongTitle");
1172 let area = Rect::new(0, 0, 4, 3);
1173 let mut pool = GraphemePool::new();
1174 let mut frame = Frame::new(4, 3, &mut pool);
1175 block.render(area, &mut frame);
1176 }
1178
1179 #[test]
1180 fn alignment_default_is_left() {
1181 assert_eq!(Alignment::default(), Alignment::Left);
1182 }
1183
1184 use crate::MeasurableWidget;
1187 use ftui_core::geometry::Size;
1188
1189 #[test]
1190 fn chrome_size_no_borders() {
1191 let block = Block::new();
1192 assert_eq!(block.chrome_size(), (0, 0));
1193 }
1194
1195 #[test]
1196 fn chrome_size_all_borders() {
1197 let block = Block::bordered();
1198 assert_eq!(block.chrome_size(), (4, 4));
1201 }
1202
1203 #[test]
1204 fn chrome_size_partial_borders() {
1205 let block = Block::new().borders(Borders::TOP | Borders::LEFT);
1206 assert_eq!(block.chrome_size(), (1, 1));
1207 }
1208
1209 #[test]
1210 fn chrome_size_horizontal_only() {
1211 let block = Block::new().borders(Borders::LEFT | Borders::RIGHT);
1212 assert_eq!(block.chrome_size(), (2, 0));
1213 }
1214
1215 #[test]
1216 fn chrome_size_vertical_only() {
1217 let block = Block::new().borders(Borders::TOP | Borders::BOTTOM);
1218 assert_eq!(block.chrome_size(), (0, 2));
1219 }
1220
1221 #[test]
1222 fn measure_no_borders() {
1223 let block = Block::new();
1224 let constraints = block.measure(Size::MAX);
1225 assert_eq!(constraints.min, Size::ZERO);
1226 assert_eq!(constraints.preferred, Size::ZERO);
1227 }
1228
1229 #[test]
1230 fn measure_all_borders() {
1231 let block = Block::bordered();
1232 let constraints = block.measure(Size::MAX);
1233 assert_eq!(constraints.min, Size::new(4, 4));
1234 assert_eq!(constraints.preferred, Size::new(4, 4));
1235 assert_eq!(constraints.max, None); }
1237
1238 #[test]
1239 fn measure_partial_borders() {
1240 let block = Block::new().borders(Borders::TOP | Borders::RIGHT);
1241 let constraints = block.measure(Size::MAX);
1242 assert_eq!(constraints.min, Size::new(1, 1));
1243 assert_eq!(constraints.preferred, Size::new(1, 1));
1244 }
1245
1246 #[test]
1247 fn has_intrinsic_size_with_borders() {
1248 let block = Block::bordered();
1249 assert!(block.has_intrinsic_size());
1250 }
1251
1252 #[test]
1253 fn has_no_intrinsic_size_without_borders() {
1254 let block = Block::new();
1255 assert!(!block.has_intrinsic_size());
1256 }
1257
1258 #[test]
1259 fn measure_is_pure() {
1260 let block = Block::bordered();
1261 let a = block.measure(Size::new(100, 50));
1262 let b = block.measure(Size::new(100, 50));
1263 assert_eq!(a, b);
1264 }
1265
1266 #[test]
1267 fn block_styled_reads_sheet() {
1268 let sheet = StyleSheet::new();
1269 let blue = ftui_render::cell::PackedRgba::rgb(0, 100, 255);
1270 sheet.define("heading", Style::new().bold().fg(blue));
1271
1272 let block = Block::styled(&sheet, "heading")
1273 .borders(Borders::ALL)
1274 .title("T");
1275 let area = Rect::new(0, 0, 8, 3);
1276 let mut pool = GraphemePool::new();
1277 let mut frame = Frame::new(8, 3, &mut pool);
1278 block.render(area, &mut frame);
1279
1280 let title_cell = frame.buffer.get(1, 0).unwrap();
1282 assert_eq!(title_cell.fg, blue);
1283 assert!(
1284 title_cell
1285 .attrs
1286 .has_flag(ftui_render::cell::StyleFlags::BOLD)
1287 );
1288
1289 let border_cell = frame.buffer.get(0, 0).unwrap();
1291 assert_eq!(border_cell.fg, blue);
1292 }
1293
1294 #[test]
1295 fn redefine_style_then_rebuild_propagates() {
1296 let sheet = StyleSheet::new();
1297 let blue = ftui_render::cell::PackedRgba::rgb(0, 100, 255);
1298 let red = ftui_render::cell::PackedRgba::rgb(255, 0, 0);
1299
1300 sheet.define("heading", Style::new().bold().fg(blue));
1301 let block1 = Block::styled(&sheet, "heading")
1302 .borders(Borders::ALL)
1303 .title("T");
1304 let area = Rect::new(0, 0, 8, 3);
1305 let mut pool1 = GraphemePool::new();
1306 let mut frame1 = Frame::new(8, 3, &mut pool1);
1307 block1.render(area, &mut frame1);
1308 assert_eq!(frame1.buffer.get(1, 0).unwrap().fg, blue);
1309 assert!(
1310 frame1
1311 .buffer
1312 .get(1, 0)
1313 .unwrap()
1314 .attrs
1315 .has_flag(ftui_render::cell::StyleFlags::BOLD)
1316 );
1317
1318 sheet.define("heading", Style::new().fg(red));
1320 let block2 = Block::styled(&sheet, "heading")
1321 .borders(Borders::ALL)
1322 .title("T");
1323 let mut pool2 = GraphemePool::new();
1324 let mut frame2 = Frame::new(8, 3, &mut pool2);
1325 block2.render(area, &mut frame2);
1326 assert_eq!(frame2.buffer.get(1, 0).unwrap().fg, red);
1327 assert!(
1328 !frame2
1329 .buffer
1330 .get(1, 0)
1331 .unwrap()
1332 .attrs
1333 .has_flag(ftui_render::cell::StyleFlags::BOLD)
1334 );
1335 }
1336
1337 #[test]
1338 fn missing_name_falls_back_to_default() {
1339 let sheet = StyleSheet::new();
1340 let block_styled = Block::styled(&sheet, "nope");
1341 let block_default = Block::default();
1342
1343 let area = Rect::new(0, 0, 10, 5);
1344 let mut pool1 = GraphemePool::new();
1345 let mut frame1 = Frame::new(10, 5, &mut pool1);
1346 block_styled.render(area, &mut frame1);
1347
1348 let mut pool2 = GraphemePool::new();
1349 let mut frame2 = Frame::new(10, 5, &mut pool2);
1350 block_default.render(area, &mut frame2);
1351
1352 assert_eq!(frame1.buffer, frame2.buffer);
1353 }
1354
1355 #[test]
1356 fn compose_precedence_name_then_border() {
1357 let sheet = StyleSheet::new();
1358 let blue = ftui_render::cell::PackedRgba::rgb(0, 100, 255);
1359 let green = ftui_render::cell::PackedRgba::rgb(0, 255, 100);
1360
1361 sheet.define("heading", Style::new().fg(blue));
1362 sheet.define("heading.border", Style::new().fg(green));
1363
1364 let block = Block::styled(&sheet, "heading")
1365 .borders(Borders::ALL)
1366 .title("T");
1367 let area = Rect::new(0, 0, 8, 3);
1368 let mut pool = GraphemePool::new();
1369 let mut frame = Frame::new(8, 3, &mut pool);
1370 block.render(area, &mut frame);
1371
1372 assert_eq!(frame.buffer.get(1, 1).unwrap().fg, blue);
1374 assert_eq!(frame.buffer.get(0, 0).unwrap().fg, green);
1376 assert_eq!(frame.buffer.get(1, 0).unwrap().fg, green);
1378 }
1379
1380 #[test]
1381 fn explicit_style_overrides_sheet() {
1382 let sheet = StyleSheet::new();
1383 let blue = ftui_render::cell::PackedRgba::rgb(0, 100, 255);
1384 let red = ftui_render::cell::PackedRgba::rgb(255, 0, 0);
1385
1386 sheet.define("heading", Style::new().fg(blue));
1387 let block = Block::styled(&sheet, "heading")
1388 .borders(Borders::ALL)
1389 .title("T")
1390 .style(Style::new().fg(red));
1391
1392 let area = Rect::new(0, 0, 8, 3);
1393 let mut pool = GraphemePool::new();
1394 let mut frame = Frame::new(8, 3, &mut pool);
1395 block.render(area, &mut frame);
1396
1397 assert_eq!(frame.buffer.get(1, 1).unwrap().fg, red);
1399 assert_eq!(frame.buffer.get(0, 0).unwrap().fg, blue);
1401 }
1402
1403 use proptest::prelude::*;
1404
1405 proptest! {
1406 #[test]
1407 fn prop_styled_block_equals_manual_block(
1408 fg_r in 0u8..255, fg_g in 0u8..255, fg_b in 0u8..255,
1409 border_r in 0u8..255, border_g in 0u8..255, border_b in 0u8..255,
1410 ) {
1411 let s = Style::new().fg(ftui_render::cell::PackedRgba::rgb(fg_r, fg_g, fg_b));
1412 let b = Style::new().fg(ftui_render::cell::PackedRgba::rgb(border_r, border_g, border_b));
1413
1414 let sheet = StyleSheet::new();
1415 sheet.define("card", s);
1416 sheet.define("card.border", b);
1417
1418 let styled = Block::styled(&sheet, "card").borders(Borders::ALL).title("Hi");
1419 let manual = Block::default()
1420 .style(s)
1421 .border_style(sheet.compose(&["card", "card.border"]))
1422 .borders(Borders::ALL)
1423 .title("Hi");
1424
1425 let area = Rect::new(0, 0, 10, 4);
1426 let mut pool1 = GraphemePool::new();
1427 let mut frame1 = Frame::new(10, 4, &mut pool1);
1428 styled.render(area, &mut frame1);
1429
1430 let mut pool2 = GraphemePool::new();
1431 let mut frame2 = Frame::new(10, 4, &mut pool2);
1432 manual.render(area, &mut frame2);
1433
1434 prop_assert_eq!(frame1.buffer, frame2.buffer);
1435 }
1436 }
1437}