termtui 0.1.0

A framework for building beautiful, responsive terminal user interfaces with a DOM-style hierarchical approach
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use crate::component::Component;

pub mod div;
pub mod rich_text;
pub mod text;

pub use div::{Div, DivStyles, EventCallbacks, KeyHandler, KeyWithModifiersHandler};
pub use rich_text::{RichText, TextSpan};
pub use text::Text;

//--------------------------------------------------------------------------------------------------
// Types
//--------------------------------------------------------------------------------------------------

/// A node in the component tree (can contain components)
#[allow(clippy::large_enum_variant)]
pub enum Node {
    /// A component that can be expanded
    Component(Box<dyn Component>),

    /// A div that can have children
    Div(Div<Node>),

    /// Text content that is rendered directly
    Text(Text),

    /// Rich text with multiple styled segments
    RichText(RichText),
}

//--------------------------------------------------------------------------------------------------
// Methods
//--------------------------------------------------------------------------------------------------

impl Node {
    /// Creates a text node with the given content.
    #[inline]
    pub fn text(content: impl Into<String>) -> Node {
        Node::Text(Text::new(content))
    }

    /// Creates a div node with no children.
    #[inline]
    pub fn div() -> Node {
        Node::Div(Div::new())
    }

    /// Creates a rich text node.
    #[inline]
    pub fn rich_text() -> Node {
        Node::RichText(RichText::new())
    }
}

//--------------------------------------------------------------------------------------------------
// Builder Methods
//--------------------------------------------------------------------------------------------------

impl Node {
    /// Adds a single child (only valid for Div variant).
    #[inline]
    pub fn child(mut self, child: impl Into<Node>) -> Self {
        if let Node::Div(ref mut div) = self {
            div.children.push(child.into());
        }
        self
    }
}

//--------------------------------------------------------------------------------------------------
// Trait Implementations
//--------------------------------------------------------------------------------------------------

impl Clone for Node {
    fn clone(&self) -> Self {
        match self {
            Node::Component(c) => Node::Component(c.clone_box()),
            Node::Div(div) => Node::Div(div.clone()),
            Node::Text(text) => Node::Text(text.clone()),
            Node::RichText(rich) => Node::RichText(rich.clone()),
        }
    }
}

impl std::fmt::Debug for Node {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Node::Component(_) => write!(f, "Node::Component(...)"),
            Node::Div(div) => write!(f, "Node::Div({div:?})"),
            Node::Text(text) => write!(f, "Node::Text({text:?})"),
            Node::RichText(rich) => write!(f, "Node::RichText({rich:?})"),
        }
    }
}

impl PartialEq for Node {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Node::Text(a), Node::Text(b)) => a == b,
            (Node::RichText(a), Node::RichText(b)) => a == b,
            // Components and containers can't be easily compared due to trait objects
            _ => false,
        }
    }
}

impl From<Text> for Node {
    fn from(text: Text) -> Self {
        Node::Text(text)
    }
}

impl From<RichText> for Node {
    fn from(rich: RichText) -> Self {
        Node::RichText(rich)
    }
}

impl From<Box<dyn Component>> for Node {
    fn from(component: Box<dyn Component>) -> Self {
        Node::Component(component)
    }
}

impl From<Div<Node>> for Node {
    fn from(div: Div<Node>) -> Self {
        Node::Div(div)
    }
}