guise-ui 1.5.0

A component library for gpui, Zed's GPU-accelerated UI framework: a themed palette, sizing tokens, 130+ composable components, a reactive state layer, and an in-app Safari-style inspector.
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

//! `Animated` — the element that plays a clip.
//!
//! Two shapes, one wrapper. Give it a [`Motion`] or a [`Sequence`] and it
//! plays once when the element mounts, no state anywhere: gpui's animation
//! element supplies the clock and the clip supplies the values, so a
//! staggered list of fifty rows is fifty stateless builders. Give it an
//! [`Animator`] instead and it renders that animator's playhead, asking the
//! window for the next frame while it is still moving.
//!
//! The values land on a wrapper `div` around your child. Offsets are relative
//! insets, so an animating element never pushes its neighbours around.

use gpui::prelude::*;
use gpui::{div, AnyElement, App, ElementId, Entity, IntoElement, Window};

use super::{Animator, Clip, Motion, Motioned, Sequence};
use crate::devtools::{Probed, ProbedAny};
use crate::transition::TransitionKind;

/// A child with a clip playing on it.
#[derive(IntoElement)]
pub struct Animated {
    id: ElementId,
    clip: Clip,
    animator: Option<Entity<Animator>>,
    child: Option<AnyElement>,
}

impl Animated {
    pub fn new(id: impl Into<ElementId>) -> Self {
        Animated {
            id: id.into(),
            clip: Clip::default(),
            animator: None,
            child: None,
        }
    }

    /// Play this motion once when the element mounts.
    pub fn motion(mut self, motion: Motion) -> Self {
        self.clip = Clip::Motion(motion);
        self
    }

    /// Play this sequence once when the element mounts.
    pub fn sequence(mut self, sequence: Sequence) -> Self {
        self.clip = Clip::Sequence(sequence);
        self
    }

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

    /// One of the stock entrances, at the default 200ms.
    pub fn enter(self, kind: TransitionKind) -> Self {
        self.motion(Motion::enter(kind))
    }

    /// Render an [`Animator`]'s playhead instead of a one-shot clip. The
    /// animator wins: whatever motion was set is ignored.
    pub fn animator(mut self, animator: &Entity<Animator>) -> Self {
        self.animator = Some(animator.clone());
        self
    }

    pub fn child(mut self, child: impl IntoElement) -> Self {
        self.child = Some(child.into_any_element());
        self
    }
}

impl RenderOnce for Animated {
    fn render(self, window: &mut Window, cx: &mut App) -> impl IntoElement {
        let child = self.child.unwrap_or_else(|| div().into_any_element());

        if let Some(animator) = self.animator {
            let frame = animator.read(cx).frame(window);
            let progress = frame.progress;
            return frame
                .apply(div())
                .child(child)
                .probe("Animated")
                .attr_with("progress", || format!("{progress:.2}"))
                .into_any_element();
        }

        div()
            .child(child)
            .animate(self.id, self.clip)
            .probe_any("Animated")
            .into_any_element()
    }
}