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