buoyant 0.7.0-alpha.1

SwiftUI-like UIs in Rust for embedded devices
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

use crate::{
    primitives::{Interpolate, Size},
    render::{AnimatedJoin, Render},
    render_target::RenderTarget,
    transition::{Direction, Transition},
};

use super::AnimationDomain;

/// An optional subtree that can be rendered with a transition.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TransitionOption<Subtree, T> {
    Some {
        subtree: Subtree,
        /// Size of the subtree, used for computing offsets
        size: Size,
        /// The transition to apply
        transition: T,
    },
    None,
}

impl<Subtree, T> TransitionOption<Subtree, T> {
    /// Constructs a new [`Self::Some`] variant
    #[must_use]
    pub const fn new_some(subtree: Subtree, size: Size, transition: T) -> Self {
        Self::Some {
            subtree,
            size,
            transition,
        }
    }
}

impl<Subtree: AnimatedJoin + Clone, T: Transition> AnimatedJoin for TransitionOption<Subtree, T> {
    fn join_from(&mut self, source: &Self, domain: &AnimationDomain) {
        if let (
            Self::Some {
                subtree: source_subtree,
                ..
            },
            Self::Some {
                subtree: target_subtree,
                ..
            },
        ) = (source, self)
        {
            target_subtree.join_from(source_subtree, domain);
        }
    }
}

impl<Subtree: Render<Color> + Clone, T: Transition, Color: Interpolate + Copy> Render<Color>
    for TransitionOption<Subtree, T>
{
    fn render(&self, render_target: &mut impl RenderTarget<ColorFormat = Color>, style: &Color) {
        if let Self::Some { subtree, .. } = self {
            subtree.render(render_target, style);
        }
    }

    fn render_animated(
        render_target: &mut impl RenderTarget<ColorFormat = Color>,
        source: &Self,
        target: &Self,
        style: &Color,
        domain: &AnimationDomain,
    ) {
        match (source, target) {
            (
                Self::Some {
                    subtree: source, ..
                },
                Self::Some {
                    subtree: target, ..
                },
            ) => {
                Subtree::render_animated(render_target, source, target, style, domain);
            }
            (
                Self::Some {
                    subtree: source_subtree,
                    size,
                    transition,
                    ..
                },
                Self::None,
            ) => {
                if !domain.is_complete() {
                    let opacity = transition.opacity(Direction::Out, domain.factor);
                    let offset = transition.transform(Direction::Out, domain.factor, *size);
                    render_target.with_layer(
                        |l| l.offset(offset).opacity(opacity),
                        |render_target| {
                            source_subtree.render(render_target, style);
                        },
                    );
                }
            }
            (
                Self::None,
                Self::Some {
                    subtree: target_subtree,
                    size,
                    transition,
                    ..
                },
            ) => {
                if domain.is_complete() {
                    target_subtree.render(render_target, style);
                } else {
                    let opacity = transition.opacity(Direction::In, domain.factor);
                    let offset = transition.transform(Direction::In, domain.factor, *size);
                    render_target.with_layer(
                        |l| l.offset(offset).opacity(opacity),
                        |render_target| {
                            target_subtree.render(render_target, style);
                        },
                    );
                }
            }
            (Self::None, Self::None) => {}
        }
    }
}