tui-lipan 0.1.0

Opinionated, component-based TUI framework for Rust - declarative components, reconciliation, layout engine, focus, overlays, and rich widgets on top of ratatui.
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
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

//! Divider widget.

mod layout;
mod node;
mod reconcile;

pub(crate) use self::reconcile::{DividerReconcile, reconcile_divider};
pub use layout::measure_divider;
pub use node::DividerNode;

use crate::core::element::{Element, ElementKind};
use crate::style::{Align, Length, Style};

/// Layout orientation (horizontal vs vertical).
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum Orientation {
    /// Horizontal orientation.
    Horizontal,
    /// Vertical orientation.
    Vertical,
}

/// A 1-cell-thick divider.
#[derive(Clone)]
pub struct Divider {
    pub(crate) orientation: Orientation,
    pub(crate) width: Length,
    pub(crate) height: Length,
    pub(crate) ch: char,
    pub(crate) style: Style,
    pub(crate) label: Option<Box<Element>>,
    pub(crate) label_alignment: Align,
    pub(crate) label_padding: u16,
    pub(crate) join_frame: bool,
}

impl Divider {
    /// Create a divider with the given orientation.
    pub fn new(orientation: Orientation) -> Self {
        match orientation {
            Orientation::Horizontal => Self::horizontal(),
            Orientation::Vertical => Self::vertical(),
        }
    }

    /// Create a horizontal divider.
    pub fn horizontal() -> Self {
        Self {
            orientation: Orientation::Horizontal,
            width: Length::Flex(1),
            height: Length::Px(1),
            ch: '─',
            style: Style::default(),
            label: None,
            label_alignment: Align::Start,
            label_padding: 1,
            join_frame: false,
        }
    }

    /// Create a vertical divider.
    pub fn vertical() -> Self {
        Self {
            orientation: Orientation::Vertical,
            width: Length::Px(1),
            height: Length::Flex(1),
            ch: '│',
            style: Style::default(),
            label: None,
            label_alignment: Align::Start,
            label_padding: 1,
            join_frame: false,
        }
    }

    /// Set style.
    pub fn style(mut self, style: Style) -> Self {
        self.style = style;
        self
    }

    /// Set an inline label (horizontal only).
    pub fn label(mut self, label: impl Into<Element>) -> Self {
        self.label = Some(Box::new(label.into()));
        self
    }

    /// Set label alignment (horizontal only).
    pub fn label_alignment(mut self, alignment: Align) -> Self {
        self.label_alignment = alignment;
        self
    }

    /// Set label padding on both sides (horizontal only).
    pub fn label_padding(mut self, padding: u16) -> Self {
        self.label_padding = padding;
        self
    }

    /// Join the divider with the nearest frame border.
    pub fn join_frame(mut self, join: bool) -> Self {
        self.join_frame = join;
        self
    }

    /// Override the divider character.
    pub fn ch(mut self, ch: char) -> Self {
        self.ch = ch;
        self
    }

    /// Override requested width.
    pub fn width(mut self, width: Length) -> Self {
        self.width = width;
        self
    }

    /// Override requested height.
    pub fn height(mut self, height: Length) -> Self {
        self.height = height;
        self
    }
}

impl From<Divider> for Element {
    fn from(value: Divider) -> Self {
        Element::new(ElementKind::Divider(value))
    }
}

impl crate::layout::hash::LayoutHash for Divider {
    fn layout_hash(
        &self,
        hasher: &mut impl std::hash::Hasher,
        recurse: &dyn Fn(&Element) -> Option<u64>,
    ) -> Option<()> {
        use std::hash::Hash;
        self.width.hash(hasher);
        self.height.hash(hasher);
        self.orientation.hash(hasher);
        self.label_alignment.hash(hasher);
        self.label_padding.hash(hasher);
        self.join_frame.hash(hasher);

        if let Some(label) = self.label.as_deref() {
            recurse(label)?.hash(hasher);
        }
        Some(())
    }
}