egui_animation 0.11.0

Experimental animation utilities for egui, including easing functions and a collapse view.
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

use crate::animate_bool_eased;
use egui::{Id, Rect, Ui, UiBuilder, Vec2};

/// Collapse animation to hide/show content.
/// Currently only vertical collapse is supported.
pub struct Collapse {
    // TODO: Implement horizontal collapse
    #[allow(dead_code)]
    horizontal: bool,
    visible: bool,
    id: Id,
    duration: Option<f32>,
}

impl Collapse {
    // pub fn horizontal(id: impl Into<Id>, visible: bool) -> Self {
    //     Self {
    //         horizontal: true,
    //         visible,
    //         id: id.into(),
    //         duration: 0.2,
    //     }
    // }

    /// Creates a new vertical collapse animation.
    pub fn vertical(id: impl Into<Id>, visible: bool) -> Self {
        Self {
            horizontal: false,
            visible,
            id: id.into(),
            duration: None,
        }
    }

    /// Sets the animation time for the collapse animation
    /// The default is the same as the egui animation time
    pub fn with_animation_time(mut self, animation_time: f32) -> Self {
        self.duration = Some(animation_time);
        self
    }

    /// Show the content.
    pub fn ui(self, ui: &mut Ui, content: impl FnOnce(&mut Ui)) {
        let id = self.id;
        let visible = self.visible;

        let x = animate_bool_eased(
            ui.ctx(),
            id,
            visible,
            simple_easing::cubic_in_out,
            self.duration.unwrap_or(ui.style().animation_time),
        );

        let last_size = ui
            .ctx()
            .memory_mut(|mem| *mem.data.get_temp_mut_or(id, 0.0));

        let mut child = ui.new_child(
            UiBuilder::new()
                .max_rect(Rect::from_min_size(
                    ui.next_widget_position(),
                    ui.available_size(),
                ))
                .layout(*ui.layout()),
        );

        let current_size = last_size * x;

        let clip_rect = ui.clip_rect().intersect(Rect::from_min_size(
            child.next_widget_position(),
            Vec2::new(child.available_size().x, current_size),
        ));

        child.set_clip_rect(clip_rect);

        content(&mut child);

        let size = child.min_size().min(ui.available_size());

        ui.memory_mut(|mem| {
            mem.data.insert_temp(id, size.y);
        });

        ui.allocate_rect(
            Rect::from_min_size(ui.next_widget_position(), Vec2::new(size.x, current_size)),
            egui::Sense::hover(),
        );
    }
}