leptos-chartistry 0.2.3

Chartistry is a charting library for Leptos
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

mod compose;
pub mod legend;
pub mod rotated_label;
pub mod tick_labels;

pub use compose::Layout;

use crate::{
    bounds::Bounds,
    edge::Edge,
    state::{PreState, State},
    Tick,
};
use leptos::prelude::*;

/// All possible layout options for an edge of a [Chart](crate::Chart). See [IntoEdge](trait@IntoEdge) for details.
#[derive(Clone)]
#[non_exhaustive]
pub enum EdgeLayout<XY: Tick> {
    /// Legend. See [legend](struct@legend::Legend) for details.
    Legend(legend::Legend),
    /// Rotated label. See [rotated_label](struct@rotated_label::RotatedLabel) for details.
    RotatedLabel(rotated_label::RotatedLabel),
    /// Tick labels. See [tick_labels](struct@tick_labels::TickLabels) for details.
    TickLabels(tick_labels::TickLabels<XY>),
}

struct UseVerticalLayout {
    width: Signal<f64>,
    layout: UseLayout,
}

#[derive(Clone)]
enum UseLayout {
    Legend(legend::Legend),
    RotatedLabel(rotated_label::RotatedLabel),
    TickLabels(tick_labels::UseTickLabels),
}

impl UseLayout {
    fn render<X: Tick, Y: Tick>(
        self,
        edge: Edge,
        bounds: Memo<Bounds>,
        state: State<X, Y>,
    ) -> impl IntoView {
        match self {
            Self::Legend(inner) => view! {<legend::Legend legend=inner edge=edge bounds=bounds state=state />}.into_any(),
            Self::RotatedLabel(inner) => view! {<rotated_label::RotatedLabel label=inner edge=edge bounds=bounds state=state />}.into_any(),
            Self::TickLabels(inner) => view! {<tick_labels::TickLabels ticks=inner edge=edge bounds=bounds state=state />}.into_any(),
        }
    }
}

impl<X: Tick> EdgeLayout<X> {
    fn fixed_height<Y: Tick>(&self, state: &PreState<X, Y>) -> Signal<f64> {
        match self {
            Self::Legend(inner) => inner.fixed_height(state),
            Self::RotatedLabel(inner) => inner.fixed_height(state),
            Self::TickLabels(inner) => inner.fixed_height(state),
        }
    }

    fn to_horizontal_use<Y: Tick>(
        &self,
        state: &PreState<X, Y>,
        avail_width: Memo<f64>,
    ) -> UseLayout {
        match self {
            Self::Legend(inner) => inner.to_horizontal_use(),
            Self::RotatedLabel(inner) => inner.to_horizontal_use(),
            Self::TickLabels(inner) => inner.to_horizontal_use(state, avail_width),
        }
    }
}

impl<Y: Tick> EdgeLayout<Y> {
    fn to_vertical_use<X: Tick>(
        &self,
        state: &PreState<X, Y>,
        avail_height: Memo<f64>,
    ) -> UseVerticalLayout {
        match self {
            Self::Legend(inner) => inner.to_vertical_use(state),
            Self::RotatedLabel(inner) => inner.to_vertical_use(state),
            Self::TickLabels(inner) => inner.to_vertical_use(state, avail_height),
        }
    }
}

/// Convert a type (e.g., a [rotated label](struct@rotated_label::RotatedLabel)) into an edge layout for use with [Chart](crate::Chart).
pub trait IntoEdge<XY: Tick> {
    /// Create an edge layout from the type. See [IntoEdge](trait@IntoEdge) for details.
    fn into_edge(self) -> EdgeLayout<XY>;
}

macro_rules! impl_into_edge {
    ($ty:ty, $enum:ident) => {
        impl<XY: Tick> IntoEdge<XY> for $ty {
            fn into_edge(self) -> EdgeLayout<XY> {
                EdgeLayout::$enum(self)
            }
        }

        impl<XY: Tick> From<$ty> for EdgeLayout<XY> {
            fn from(inner: $ty) -> Self {
                inner.into_edge()
            }
        }

        impl<XY: Tick> From<$ty> for Vec<EdgeLayout<XY>> {
            fn from(inner: $ty) -> Self {
                vec![inner.into_edge()]
            }
        }
    };
}
impl_into_edge!(legend::Legend, Legend);
impl_into_edge!(rotated_label::RotatedLabel, RotatedLabel);
impl_into_edge!(tick_labels::TickLabels<XY>, TickLabels);