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