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

use std::any::Any;

use crate::style::Theme;

/// Type-erased, cloneable component properties.
pub(crate) struct AnyProps {
    pub(crate) value: Box<dyn Any>,
    clone_fn: fn(&Box<dyn Any>) -> Box<dyn Any>,
    eq_fn: fn(&dyn Any, &dyn Any) -> bool,
}

impl Clone for AnyProps {
    fn clone(&self) -> Self {
        Self {
            value: (self.clone_fn)(&self.value),
            clone_fn: self.clone_fn,
            eq_fn: self.eq_fn,
        }
    }
}

impl AnyProps {
    pub(crate) fn new<P>(props: P) -> Self
    where
        P: Clone + PartialEq + 'static,
    {
        fn clone_value<P>(v: &Box<dyn Any>) -> Box<dyn Any>
        where
            P: Clone + 'static,
        {
            let p = v.downcast_ref::<P>().unwrap_or_else(|| {
                let expected = std::any::type_name::<P>();
                let actual = std::any::type_name_of_val(v.as_ref());
                panic!("AnyProps type mismatch (expected `{expected}`, got `{actual}`)");
            });
            Box::new(p.clone())
        }

        fn eq_value<P>(a: &dyn Any, b: &dyn Any) -> bool
        where
            P: PartialEq + 'static,
        {
            match (a.downcast_ref::<P>(), b.downcast_ref::<P>()) {
                (Some(a), Some(b)) => a == b,
                _ => false,
            }
        }

        Self {
            value: Box::new(props),
            clone_fn: clone_value::<P>,
            eq_fn: eq_value::<P>,
        }
    }

    pub(crate) fn downcast_ref<P: 'static>(&self) -> Option<&P> {
        self.value.downcast_ref::<P>()
    }

    pub(crate) fn into_typed<P: 'static>(self) -> Option<P> {
        self.value.downcast::<P>().ok().map(|v| *v)
    }

    pub(crate) fn type_name(&self) -> &'static str {
        std::any::type_name_of_val(self.value.as_ref())
    }

    #[cfg(debug_assertions)]
    pub(crate) fn debug_eq(&self, other: &Self) -> bool {
        if self.value.as_ref().type_id() != other.value.as_ref().type_id() {
            return false;
        }
        (self.eq_fn)(self.value.as_ref(), other.value.as_ref())
    }
}

/// Trait for component properties that can be themed.
pub trait ThemableProps {
    /// Apply a theme to the properties.
    fn apply_theme(&mut self, theme: &Theme);
}