Skip to main content

ftui_widgets/
block.rs

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/// A widget that draws a block with optional borders, title, and padding.
15#[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/// Text alignment.
27#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
28pub enum Alignment {
29    #[default]
30    /// Align text to the left.
31    Left,
32    /// Center text horizontally.
33    Center,
34    /// Align text to the right.
35    Right,
36}
37
38impl<'a> Block<'a> {
39    /// Create a new block with default settings.
40    #[must_use]
41    pub fn new() -> Self {
42        Self::default()
43    }
44
45    /// Create a block with all borders enabled and default padding.
46    #[must_use]
47    pub fn bordered() -> Self {
48        Self::default().borders(Borders::ALL).padding(Sides::all(1))
49    }
50
51    /// Create a new block styled from a [`StyleSheet`] by name.
52    ///
53    /// Sets the block's inner style to `sheet.get_or_default(name)` and composes
54    /// its border style from `[name, format!("{name}{BLOCK_BORDER_SUFFIX}")]`
55    /// (e.g. `["heading", "heading.border"]`), allowing a border-specific style
56    /// to override base properties.
57    ///
58    /// Subsequent calls to [`style`](Self::style) or
59    /// [`border_style`](Self::border_style) will override these values.
60    #[must_use]
61    pub fn styled(sheet: &StyleSheet, name: &str) -> Self {
62        Self::default().with_stylesheet(sheet, name)
63    }
64
65    /// Apply styles from a [`StyleSheet`] to this block.
66    ///
67    /// Sets the block's inner style to `sheet.get_or_default(name)` and composes
68    /// its border style from `[name, format!("{name}{BLOCK_BORDER_SUFFIX}")]`
69    /// (e.g. `["heading", "heading.border"]`), allowing a border-specific style
70    /// to override base properties.
71    ///
72    /// Subsequent calls to [`style`](Self::style) or
73    /// [`border_style`](Self::border_style) will override these values.
74    #[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    /// Set which borders to render.
85    #[must_use]
86    pub fn borders(mut self, borders: Borders) -> Self {
87        self.borders = borders;
88        self
89    }
90
91    /// Set the style applied to border characters.
92    #[must_use]
93    pub fn border_style(mut self, style: Style) -> Self {
94        self.border_style = style;
95        self
96    }
97
98    /// Set the border character set (e.g. square, rounded, double).
99    #[must_use]
100    pub fn border_type(mut self, border_type: BorderType) -> Self {
101        self.border_type = border_type;
102        self
103    }
104
105    /// Set the padding inside the borders.
106    #[must_use]
107    pub fn padding(mut self, padding: impl Into<Sides>) -> Self {
108        self.padding = padding.into();
109        self
110    }
111
112    /// Get the border set for this block.
113    pub(crate) fn border_set(&self) -> BorderSet {
114        self.border_type.to_border_set()
115    }
116
117    /// Set the block title displayed on the top border.
118    #[must_use]
119    pub fn title(mut self, title: &'a str) -> Self {
120        self.title = Some(title);
121        self
122    }
123
124    /// Return the title text, if any.
125    #[must_use]
126    pub fn title_text(&self) -> Option<&str> {
127        self.title
128    }
129
130    /// Set the horizontal alignment of the title.
131    #[must_use]
132    pub fn title_alignment(mut self, alignment: Alignment) -> Self {
133        self.title_alignment = alignment;
134        self
135    }
136
137    /// Set the background style for the entire block area.
138    #[must_use]
139    pub fn style(mut self, style: Style) -> Self {
140        self.style = style;
141        self
142    }
143
144    /// Compute the inner area inside the block's borders and padding.
145    #[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    /// Calculate the chrome (border + padding) size consumed by this block.
168    ///
169    /// Returns `(horizontal_chrome, vertical_chrome)` representing the
170    /// total width and height consumed by borders and padding.
171    #[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    /// Create a styled border cell.
188    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        // Edges
202        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        // Corners (drawn after edges to overwrite edge characters at corners)
226        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    /// Render borders using ASCII characters regardless of configured border_type.
253    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        // After the emptiness check, not before it. A block laid out into an
361        // empty area draws nothing, so announcing a Group for it puts a
362        // container in the tree that has no extent, cannot be focused and was
363        // never on screen. It also collides: `a11y_node_id` hashes the rect,
364        // so every widget clipped away lands on the id of the same empty rect
365        // and `add_node` keeps only the last - see
366        // bd-a11y-sibling-id-collision-6zqd2.
367        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        // Skeleton+: skip everything, just clear area
379        if !deg.render_content() {
380            frame.buffer.fill(area, Cell::default());
381            return;
382        }
383
384        // EssentialOnly: block chrome is purely decorative, so clear the owned
385        // area instead of leaving stale borders/title content behind.
386        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        // Apply background/style
395        if deg.apply_styling() {
396            set_style_area(&mut frame.buffer, area, self.style);
397        }
398
399        // Render borders (with possible ASCII downgrade)
400        if deg.use_unicode_borders() {
401            self.render_borders(area, &mut frame.buffer, border_style);
402        } else {
403            // Force ASCII borders regardless of configured border_type
404            self.render_borders_ascii(area, &mut frame.buffer, border_style);
405        }
406
407        // Render title (skip at NoStyling to save time)
408        if deg.apply_styling() {
409            self.render_title(area, frame);
410        } else if deg.render_decorative() {
411            // Still show title but without styling
412            // Pass frame to reuse draw_text_span
413            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                    // draw_text_span() preserves existing cell styles. Clear the
435                    // title span first so NoStyling truly drops border styling.
436                    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        // Block's intrinsic size is just its chrome (borders).
453        // The minimum is the chrome size - less than this and borders overlap.
454        // Preferred is also the chrome size - any inner content adds to this.
455        // Maximum is unbounded - block can fill available space.
456        SizeConstraints::at_least(chrome, chrome)
457    }
458
459    fn has_intrinsic_size(&self) -> bool {
460        // Block has intrinsic size only if it has borders
461        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
480// ============================================================================
481// Accessibility
482// ============================================================================
483
484impl 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        // Dashed vertical edge and square corners at the bottom.
570        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        // 1x1 with all borders: x+1=1, w-2=0, y+1=1, h-2=0
721        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        // Title "Hi" (2 chars) in 8 available (10-2 borders), centered at offset 3
855        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        // Available width = 6, title width = 2 => center offset 2 => x = 3
872        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        // "Hi" right-aligned: right()-1 - 2 = col 7
894        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        // No title should appear on row 0
949        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        // Top and bottom should have horizontal lines
978        assert_eq!(buf.get(2, 0).unwrap().content.as_char(), Some('─'));
979        assert_eq!(buf.get(2, 2).unwrap().content.as_char(), Some('─'));
980        // Left edge should be empty (no vertical border)
981        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        // Width 3 with all borders = 1 char available for title
1171        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        // Should not panic, title gets truncated
1177    }
1178
1179    #[test]
1180    fn alignment_default_is_left() {
1181        assert_eq!(Alignment::default(), Alignment::Left);
1182    }
1183
1184    // --- MeasurableWidget tests ---
1185
1186    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        // Block::bordered() includes 1 cell padding on each side.
1199        // Chrome = borders (2) + padding (2) = 4 on each axis.
1200        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); // Unbounded
1236    }
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        // Title cell at (1, 0) should be bold + blue
1281        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        // Border cell at (0, 0) should carry composed style (blue)
1290        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        // Redefine as red without bold
1319        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        // Inner cell uses base style (blue)
1373        assert_eq!(frame.buffer.get(1, 1).unwrap().fg, blue);
1374        // Border cell uses composed style where border overrides (green)
1375        assert_eq!(frame.buffer.get(0, 0).unwrap().fg, green);
1376        // Title cell on border also uses border_style (green)
1377        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        // Inner area cell gets explicit style (red)
1398        assert_eq!(frame.buffer.get(1, 1).unwrap().fg, red);
1399        // Border cell still has sheet border_style (blue)
1400        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}