ctl-layout 0.7.1

Terminal widgets built on ctl-text: tables, records, rules, stacks, and indents
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

//! A widget moved right.

use std::fmt;

use ctl_text::{Context, Line, Measurement, Renderable};

use crate::lines::indent_lines;

/// A widget moved right by a number of cells.
///
/// The child gets the width that is left, but never less than 1 cell. So a
/// child still draws when the indent is as wide as the context. A blank line
/// stays blank.
///
/// The child may be borrowed, as in `Indent::new(2, &widget)`.
pub struct Indent<'a> {
    columns: u16,
    child: Box<dyn Renderable + 'a>,
}

impl<'a> Indent<'a> {
    /// `child` moved right by `cells` cells.
    #[must_use]
    pub fn new(cells: u16, child: impl Renderable + 'a) -> Self {
        Self {
            columns: cells,
            child: Box::new(child),
        }
    }

    fn inner(&self, context: &Context) -> Context {
        context.at_width(context.width().saturating_sub(self.columns).max(1))
    }
}

impl fmt::Debug for Indent<'_> {
    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
        formatter
            .debug_struct("Indent")
            .field("columns", &self.columns)
            .finish_non_exhaustive()
    }
}

impl Renderable for Indent<'_> {
    fn measure(&self, context: &Context) -> Measurement {
        let measured = self.child.measure(&self.inner(context));
        Measurement::new(
            measured.minimum().saturating_add(self.columns),
            measured.maximum().saturating_add(self.columns),
        )
    }

    fn render(&self, context: &Context) -> Vec<Line> {
        indent_lines(self.child.render(&self.inner(context)), self.columns)
    }
}