Struct AnyElement 

pub struct AnyElement(/* private fields */);

An element with its concrete type erased, so that elements of different types can share one type.

Use it when a function must return one type but its branches build different elements, or when a list holds elements of mixed types. Create one with IntoElement::into_any_element or Element::into_any. Its methods run the same phases as the element it wraps.

Example

use gpui::{AnyElement, Div, IntoElement, div, prelude::*};

fn label(wide: bool) -> AnyElement {
    if wide {
        div().w_full().child("Wide").into_any_element()
    } else {
        "Narrow".into_any_element()
    }
}

let mut wide = label(true);
assert!(wide.downcast_mut::<Div>().is_some());

let mut narrow = label(false);
assert!(narrow.downcast_mut::<Div>().is_none());

Implementations

impl AnyElement

pub fn downcast_mut<T: 'static>(&mut self) -> Option<&mut T>

Returns a mutable reference to the wrapped element if it has type T, or None otherwise.

pub fn request_layout(&mut self, window: &mut Window, cx: &mut App) -> LayoutId

Runs the request-layout phase on the wrapped element, and returns its layout id.

Call this from a parent’s request_layout, before the parent’s own layout is requested.

pub fn prepaint( &mut self, window: &mut Window, cx: &mut App, ) -> Option<FocusHandle>

Runs the prepaint phase on the wrapped element, with the bounds that layout gave it.

Returns the FocusHandle of a focused element in this subtree, if one became focused during this call. Otherwise returns None.

pub fn paint(&mut self, window: &mut Window, cx: &mut App)

Runs the paint phase on the wrapped element. Call it after AnyElement::prepaint.

pub fn layout_as_root( &mut self, available_space: Size<AvailableSpace>, window: &mut Window, cx: &mut App, ) -> Size<Pixels>

Lays out this element as the root of its own layout, within available_space, and returns its size.

The element is not placed in the window by this call. Use it to measure an element before placing it with AnyElement::prepaint_at. If the layout hasn’t been requested yet, this method requests it first.

pub fn prepaint_at( &mut self, origin: Point<Pixels>, window: &mut Window, cx: &mut App, ) -> Option<FocusHandle>

Runs the prepaint phase with origin as the element’s origin, in window coordinates.

Call AnyElement::layout_as_root first, or use AnyElement::prepaint_as_root, which does both. Returns the focus handle of a focused element in the subtree that became focused during this call, if any.

pub fn prepaint_as_root( &mut self, origin: Point<Pixels>, available_space: Size<AvailableSpace>, window: &mut Window, cx: &mut App, ) -> Option<FocusHandle>

Lays out this element as a root within available_space, then prepaints it at origin.

Use it for an element that sits outside its parent’s layout, such as a popover placed at a window position. Returns the focus handle of a focused element in the subtree that became focused during this call, if any.

Trait Implementations

impl Element for AnyElement

type RequestLayoutState = ()

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, _: 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, _: Option<&GlobalElementId>, _inspector_id: Option<&InspectorElementId>, _: Bounds<Pixels>, _: &mut Self::RequestLayoutState, window: &mut Window, cx: &mut App, )

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

fn paint( &mut self, _: Option<&GlobalElementId>, _inspector_id: Option<&InspectorElementId>, _: Bounds<Pixels>, _: &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 IntoElement for AnyElement

type Element = AnyElement

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.