freya-components 0.4.0-alpha.6

Components for Freya apps
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

use std::time::Duration;

use freya_animation::prelude::{
    AnimDirection,
    AnimNum,
    Ease,
    Function,
    OnFinish,
    use_animation,
};
use freya_core::prelude::*;
use torin::{
    prelude::Area,
    size::Size,
};

/// Animate the content of a container when the content overflows.
///
/// This is primarily targeted to text that can't be fully shown in small layouts.
///
/// # Example
///
/// ```rust
/// # use freya::prelude::*;
/// fn app() -> impl IntoElement {
///     Button::new().child(
///         OverflowedContent::new().width(Size::px(100.)).child(
///             label()
///                 .text("Freya is a cross-platform GUI library for Rust")
///                 .max_lines(1),
///         ),
///     )
/// }
/// ```
#[derive(Clone, PartialEq)]
pub struct OverflowedContent {
    children: Vec<Element>,
    width: Size,
    height: Size,
    duration: Duration,
    key: DiffKey,
}

impl Default for OverflowedContent {
    fn default() -> Self {
        Self::new()
    }
}

impl ChildrenExt for OverflowedContent {
    fn get_children(&mut self) -> &mut Vec<Element> {
        &mut self.children
    }
}

impl KeyExt for OverflowedContent {
    fn write_key(&mut self) -> &mut DiffKey {
        &mut self.key
    }
}

impl OverflowedContent {
    pub fn new() -> Self {
        Self {
            children: Vec::new(),
            width: Size::fill(),
            height: Size::auto(),
            duration: Duration::from_secs(4),
            key: DiffKey::None,
        }
    }

    pub fn width(mut self, width: impl Into<Size>) -> Self {
        self.width = width.into();
        self
    }

    pub fn height(mut self, height: impl Into<Size>) -> Self {
        self.height = height.into();
        self
    }

    pub fn duration(mut self, duration: Duration) -> Self {
        self.duration = duration;
        self
    }
}

impl Render for OverflowedContent {
    fn render(&self) -> impl IntoElement {
        let mut label_size = use_state(Area::default);
        let mut rect_size = use_state(Area::default);

        let rect_width = rect_size.read().width();
        let label_width = label_size.read().width();
        let does_overflow = label_width > rect_width;

        let duration = self.duration;
        let animation = use_animation(move |conf| {
            conf.on_finish(OnFinish::Restart);

            AnimNum::new(0., 100.)
                .duration(duration)
                .ease(Ease::InOut)
                .function(Function::Linear)
        });

        use_side_effect_with_deps(&does_overflow, move |does_overflow| {
            if *does_overflow {
                animation.run(AnimDirection::Forward);
            }
        });

        let progress = animation.get().value();
        let offset_x = if does_overflow {
            ((label_width + rect_width) * progress / 100.) - rect_width
        } else {
            0.
        };

        rect()
            .width(self.width.clone())
            .height(self.height.clone())
            .offset_x(-offset_x)
            .overflow(Overflow::Clip)
            .on_sized(move |e: Event<SizedEventData>| rect_size.set(e.area))
            .child(
                rect()
                    .on_sized(move |e: Event<SizedEventData>| label_size.set(e.area))
                    .children(self.children.clone()),
            )
    }

    fn render_key(&self) -> DiffKey {
        self.key.clone().or(self.default_key())
    }
}