Struct AnimationElement 

pub struct AnimationElement<E> { /* private fields */ }

The element returned by AnimationExt::with_animation and AnimationExt::with_animations.

It wraps the element being animated and runs the animator on each frame.

Implementations

impl<E> AnimationElement<E>

pub fn map_element(self, f: impl FnOnce(E) -> E) -> AnimationElement<E>

Applies f to the element being animated, and returns the animation with the result.

The animator still runs on the element that f returns.

Examples

use std::time::Duration;

use gpui::{Animation, AnimationExt, div, prelude::*, px};

let _fade = div()
    .child("Saved")
    .with_animation(
        "fade",
        Animation::new(Duration::from_millis(200)),
        |el, delta| el.opacity(delta),
    )
    .map_element(|el| el.w(px(120.)));

Trait Implementations

impl<E: IntoElement + 'static> Element for AnimationElement<E>

type RequestLayoutState = AnyElement

The state that Element::request_layout returns for the later phases.

type PrepaintState = ()

The state that Element::prepaint returns for Element::paint.

fn id(&self) -> Option<ElementId>

Returns the element’s identity, or None if it has none.

fn source_location(&self) -> Option<&'static Location<'static>>

Returns where this element was created, for the inspector and debug output.

fn request_layout( &mut self, global_id: Option<&GlobalElementId>, _inspector_id: Option<&InspectorElementId>, window: &mut Window, cx: &mut App, ) -> (LayoutId, Self::RequestLayoutState)

Requests a layout node from Taffy, and returns it with the state the later phases need.

fn prepaint( &mut self, _id: Option<&GlobalElementId>, _inspector_id: Option<&InspectorElementId>, _bounds: Bounds<Pixels>, element: &mut Self::RequestLayoutState, window: &mut Window, cx: &mut App, ) -> Self::PrepaintState

Runs once the element’s bounds are known, and returns the state that paint needs.

fn paint( &mut self, _id: Option<&GlobalElementId>, _inspector_id: Option<&InspectorElementId>, _bounds: Bounds<Pixels>, element: &mut Self::RequestLayoutState, _: &mut Self::PrepaintState, window: &mut Window, cx: &mut App, )

Draws the element. Runs after prepaint, once per frame.

fn a11y_role(&self) -> Option<Role>

Returns the accessible role for this element, if any. Elements that return None have no accessibility node unless Element::is_a11y_hidden returns true.

fn is_a11y_hidden(&self) -> bool

Whether assistive technology should ignore this element and its descendants.

fn write_a11y_info(&self, _node: &mut Node)

Write accessibility properties to the given node. GPUI calls this only when Element::a11y_role returns Some or Element::is_a11y_hidden returns true.

fn a11y_synthetic_children( &mut self, _prepaint: &mut Self::PrepaintState, _builder: &mut A11ySubtreeBuilder<'_>, )

Add synthetic child nodes to an Element. The element must have an .id(). It must also have a .role() or return true from Element::is_a11y_hidden.

fn into_any(self) -> AnyElement

Convert this element into a dynamically-typed AnyElement.

impl<E: IntoElement + 'static> IntoElement for AnimationElement<E>

type Element = AnimationElement<E>

The element type that this type converts into.

fn into_element(self) -> Self::Element

Converts self into an Element.

fn into_any_element(self) -> AnyElement

Converts self into an AnyElement, with its concrete type erased.

impl<E: ParentElement> ParentElement for AnimationElement<E>

fn extend(&mut self, elements: impl IntoIterator<Item = AnyElement>)

Adds the given children to the end of this element’s children.

fn child(self, child: impl IntoElement) -> Self

where Self: Sized,

Adds one child to this element, and returns the element for chaining.

fn children(self, children: impl IntoIterator<Item = impl IntoElement>) -> Self

where Self: Sized,

Adds several children to this element, in iteration order, and returns the element.