gpui-base 0.6.0

Behavior, interaction, and infrastructure foundations for GPUI applications.
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

use gpui::{
    AnyElement, App, Div, ElementId, IntoElement, ParentElement, RenderOnce, Styled, Window, div,
};

use crate::MotionReveal;

enum Child {
    Element(AnyElement),
    Content(AnyElement),
}

/// An unstyled controlled region whose content can be expanded or collapsed.
#[derive(IntoElement)]
pub struct Collapsible {
    base: Div,
    children: Vec<Child>,
    open: bool,
    reveal: Option<(ElementId, f32)>,
}

impl Collapsible {
    pub fn new() -> Self {
        Self {
            base: div(),
            children: Vec::new(),
            open: false,
            reveal: None,
        }
    }

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

    pub fn content(mut self, content: impl IntoElement) -> Self {
        self.children
            .push(Child::Content(content.into_any_element()));
        self
    }

    /// Keeps content mounted and reveals it at normalized `progress`.
    pub fn reveal(mut self, id: impl Into<ElementId>, progress: f32) -> Self {
        self.reveal = Some((id.into(), progress));
        self
    }
}

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

impl Styled for Collapsible {
    fn style(&mut self) -> &mut gpui::StyleRefinement {
        self.base.style()
    }
}

impl ParentElement for Collapsible {
    fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>) {
        self.children
            .extend(elements.into_iter().map(Child::Element));
    }
}

impl RenderOnce for Collapsible {
    fn render(self, _: &mut Window, _: &mut App) -> impl IntoElement {
        self.base
            .children(self.children.into_iter().filter_map(|child| match child {
                Child::Element(element) => Some(element),
                Child::Content(content) => match &self.reveal {
                    Some((id, progress)) => {
                        Some(MotionReveal::new(id.clone(), *progress, content).into_any_element())
                    }
                    None => self.open.then_some(content),
                },
            }))
    }
}

#[cfg(test)]
mod tests {
    use gpui::{Context, InteractiveElement as _, Render, TestAppContext, px};

    use super::*;

    struct Harness(bool);

    impl Render for Harness {
        fn render(&mut self, _: &mut Window, _: &mut Context<Self>) -> impl IntoElement {
            Collapsible::new()
                .open(self.0)
                .child(div().debug_selector(|| "trigger".into()).size(px(10.)))
                .content(div().debug_selector(|| "content".into()).size(px(10.)))
        }
    }

    #[gpui::test]
    fn content_is_only_rendered_while_open(cx: &mut TestAppContext) {
        let (_, cx) = cx.add_window_view(|_, _| Harness(false));
        cx.update(|window, cx| window.draw(cx).clear(cx));
        assert!(cx.debug_bounds("trigger").is_some());
        assert!(cx.debug_bounds("content").is_none());

        let (_, cx) = cx.add_window_view(|_, _| Harness(true));
        cx.update(|window, cx| window.draw(cx).clear(cx));
        assert!(cx.debug_bounds("trigger").is_some());
        assert!(cx.debug_bounds("content").is_some());
    }
}