Struct Anchored 

pub struct Anchored { /* private fields */ }

An anchored element that can be used to display UI that will avoid overflowing the window bounds.

Implementations

impl Anchored

pub fn anchor(self, anchor: Anchor) -> Anchored

Sets which corner of the anchored element should be anchored to the current position.

pub fn position(self, anchor: Point<Pixels>) -> Anchored

Sets the position in window coordinates (otherwise the location the anchored element is rendered is used)

pub fn attach(self, target: Bounds<Pixels>, corner: Anchor) -> Anchored

Places the element next to target, with the element’s Anchored::anchor corner on corner of target. For example, a submenu puts its top-left corner on its row’s top-right corner. Use this instead of Anchored::position.

If the element doesn’t fit in the window, it moves to the other side of target, as long as that side fits better. A submenu moves from the right of its row to the left, and a dropdown moves from below its button to above. The offset flips with it. AnchoredFitMode::SwitchAnchor has no effect here.

pub fn offset(self, offset: Point<Pixels>) -> Anchored

Offset the final position by this amount. Useful when you want to anchor to an element but offset from it, such as in PopoverMenu.

pub fn position_mode(self, mode: AnchoredPositionMode) -> Anchored

Sets the position mode for this anchored element. Local will have this interpret its Anchored::position or Anchored::attach target as relative to the parent element. While Window will have it interpret the position as relative to the window.

pub fn snap_to_window(self) -> Anchored

Snap to window edge instead of switching anchor corner when an overflow would occur.

pub fn snap_to_window_with_margin( self, edges: impl Into<Edges<Pixels>>, ) -> Anchored

Snap to window edge and leave some margins.

Trait Implementations

impl Element for Anchored

type RequestLayoutState = AnchoredState

The type of state returned from Element::request_layout. A mutable reference to this state is subsequently provided to Element::prepaint and Element::paint.

type PrepaintState = ()

The type of state returned from Element::prepaint. A mutable reference to this state is subsequently provided to Element::paint.

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

If this element has a unique identifier, return it here. This is used to track elements across frames, and will cause a GlobalElementId to be passed to the request_layout, prepaint, and paint methods.

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

Source location where this element was constructed, used to disambiguate elements in the inspector and navigate to their source code.

fn request_layout( &mut self, _id: Option<&GlobalElementId>, _inspector_id: Option<&InspectorElementId>, window: &mut Window, cx: &mut App, ) -> (LayoutId, <Anchored as Element>::RequestLayoutState)

Before an element can be painted, we need to know where it’s going to be and how big it is. Use this method to request a layout from Taffy and initialize the element’s state.

fn prepaint( &mut self, _id: Option<&GlobalElementId>, _inspector_id: Option<&InspectorElementId>, bounds: Bounds<Pixels>, request_layout: &mut <Anchored as Element>::RequestLayoutState, window: &mut Window, cx: &mut App, )

After laying out an element, we need to commit its bounds to the current frame for hitbox purposes. The state argument is the same state that was returned from Element::request_layout().

fn paint( &mut self, _id: Option<&GlobalElementId>, _inspector_id: Option<&InspectorElementId>, _bounds: Bounds<Pixels>, _request_layout: &mut <Anchored as Element>::RequestLayoutState, _prepaint: &mut <Anchored as Element>::PrepaintState, window: &mut Window, cx: &mut App, )

Once layout has been completed, this method will be called to paint the element to the screen. The state argument is the same state that was returned from Element::request_layout().

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

Returns the accessible role for this element, if any. Elements that return None are not included in the accessibility tree.

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

Write accessibility properties to the given node. Called only when a11y_role() returns Some.

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

Add synthetic child nodes to an Element that has an .id() and a .role().

fn into_any(self) -> AnyElement

Convert this element into a dynamically-typed AnyElement.

impl IntoElement for Anchored

type Element = Anchored

The specific type of element into which the implementing type is converted. Useful for converting other types into elements automatically, like Strings

fn into_element(self) -> <Anchored as IntoElement>::Element

Convert self into a type that implements Element.

fn into_any_element(self) -> AnyElement

Convert self into a dynamically-typed AnyElement.

impl ParentElement for Anchored

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

Extend this element’s children with the given child elements.

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

where Self: Sized,

Add a single child element to this element.

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

where Self: Sized,

Add multiple child elements to this element.