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
151
152
153
154
155
156

use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use std::sync::Arc;

use crate::core::node::{NodeKind, WidgetNode};
use crate::style::{Color, Length, Style};
use crate::utils::gradient::{ColorGradient, GradientDirection};

use super::animation::FrameSequence;
use super::{AsciiCanvas, AsciiCell};

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct AsciiCanvasRenderKey {
    hash: u64,
}

impl AsciiCanvasRenderKey {
    fn new(canvas: &AsciiCanvas) -> Self {
        let mut hasher = DefaultHasher::new();
        canvas.lines.hash(&mut hasher);
        canvas.cells.hash(&mut hasher);
        canvas.grid_size.hash(&mut hasher);
        canvas.style.hash(&mut hasher);
        canvas.background.hash(&mut hasher);
        canvas.gradient.hash(&mut hasher);
        // Hash color_map entries if present.
        if let Some(ref map) = canvas.color_map {
            map.hash(&mut hasher);
        }
        if let Some(ref map) = canvas.fg_color_map {
            map.hash(&mut hasher);
        }
        if let Some(ref map) = canvas.bg_color_map {
            map.hash(&mut hasher);
        }
        // Hash sequence identity + current frame for multi-frame mode
        if let Some(ref seq) = canvas.sequence {
            Arc::as_ptr(seq).hash(&mut hasher);
            canvas.current_frame.hash(&mut hasher);
        }
        Self {
            hash: hasher.finish(),
        }
    }
}

#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct AsciiCanvasWidgetKey {
    pub(crate) render_key: AsciiCanvasRenderKey,
    pub(crate) width: Length,
    pub(crate) height: Length,
}

impl AsciiCanvasWidgetKey {
    fn new(canvas: &AsciiCanvas, render_key: AsciiCanvasRenderKey) -> Self {
        Self {
            render_key,
            width: canvas.width,
            height: canvas.height,
        }
    }
}

#[derive(Clone)]
pub struct AsciiCanvasNode {
    pub lines: Vec<Arc<str>>,
    pub cells: Option<Arc<[AsciiCell]>>,
    pub grid_size: Option<(u16, u16)>,
    pub sequence: Option<Arc<FrameSequence>>,
    pub current_frame: usize,
    pub style: Style,
    pub background: Option<Style>,
    pub width: Length,
    pub height: Length,
    pub gradient: Option<(ColorGradient, GradientDirection)>,
    /// Color remapping applied at render time (source → replacement), both channels.
    pub color_map: Option<Arc<[(Color, Color)]>>,
    /// Color remapping applied at render time, foreground only.
    pub fg_color_map: Option<Arc<[(Color, Color)]>>,
    /// Color remapping applied at render time, background only.
    pub bg_color_map: Option<Arc<[(Color, Color)]>>,
    pub(crate) render_key: AsciiCanvasRenderKey,
    pub(crate) widget_key: AsciiCanvasWidgetKey,
}

impl Default for AsciiCanvasNode {
    fn default() -> Self {
        let render_key = AsciiCanvasRenderKey { hash: 0 };
        Self {
            lines: Vec::new(),
            cells: None,
            grid_size: None,
            sequence: None,
            current_frame: 0,
            style: Style::default(),
            background: None,
            width: Length::Auto,
            height: Length::Auto,
            gradient: None,
            color_map: None,
            fg_color_map: None,
            bg_color_map: None,
            render_key,
            widget_key: AsciiCanvasWidgetKey {
                render_key,
                width: Length::Auto,
                height: Length::Auto,
            },
        }
    }
}

impl WidgetNode for AsciiCanvasNode {}

impl From<AsciiCanvas> for AsciiCanvasNode {
    fn from(canvas: AsciiCanvas) -> Self {
        let render_key = AsciiCanvasRenderKey::new(&canvas);
        let widget_key = AsciiCanvasWidgetKey::new(&canvas, render_key);
        Self {
            lines: canvas.lines,
            cells: canvas.cells,
            grid_size: canvas.grid_size,
            sequence: canvas.sequence,
            current_frame: canvas.current_frame,
            style: canvas.style,
            background: canvas.background,
            width: canvas.width,
            height: canvas.height,
            gradient: canvas.gradient,
            color_map: canvas.color_map,
            fg_color_map: canvas.fg_color_map,
            bg_color_map: canvas.bg_color_map,
            render_key,
            widget_key,
        }
    }
}

impl AsciiCanvasNode {
    pub(crate) fn render_key_for(canvas: &AsciiCanvas) -> AsciiCanvasRenderKey {
        AsciiCanvasRenderKey::new(canvas)
    }

    pub(crate) fn widget_key_for(
        canvas: &AsciiCanvas,
        render_key: AsciiCanvasRenderKey,
    ) -> AsciiCanvasWidgetKey {
        AsciiCanvasWidgetKey::new(canvas, render_key)
    }
}

impl From<AsciiCanvasNode> for NodeKind {
    fn from(node: AsciiCanvasNode) -> Self {
        NodeKind::AsciiCanvas(node)
    }
}