Struct RoundedFrameCover 

pub struct RoundedFrameCover { /* private fields */ }

Keeps a rounded scroll viewport’s corners clean at every scroll offset.

GPUI clips children with a rectangular content mask, so content scrolled under a rounded frame paints square into the corner notches — the regions inside the frame’s rect corners but outside its border arcs. Rounding the content itself (e.g. a table’s first row) only helps while its own corners sit at the viewport corners; once the content scrolls, the clipped edge meets the notch square again. The cover fills each notch with the backdrop color, which reads as a rounded clip. The frame’s own border needs no help: gpui paints an element’s border after its children, so it already draws over both the scrolled content and these covers.

Like ScrollableMask, it must be a sibling of the scrolled element so it does not move with the scroll offset.

Implementations

impl RoundedFrameCover

pub fn uniform(radius: Pixels) -> Self

A frame with the same radius on all four corners.

pub fn frame_border(self, width: Pixels) -> Self

The frame’s border width, when the cover is a child of the bordered element itself: the cover’s bounds are then the content box, so the painted notches are grown outward by this width to reach the border box. The border itself needs no repaint — gpui paints an element’s border after its children, so the frame’s own border already draws over the covers.

pub fn backdrop(self, color: Hsla) -> Self

The color behind the frame, used to fill the corner notches. Defaults to the theme background.

Trait Implementations

impl Element for RoundedFrameCover

type RequestLayoutState = ()

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 = Bounds<Pixels>

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

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, _: Option<&GlobalElementId>, _: Option<&InspectorElementId>, _: Bounds<Pixels>, _: &mut Self::RequestLayoutState, cover_bounds: &mut Self::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 RoundedFrameCover

type Element = RoundedFrameCover

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) -> Self::Element

Convert self into a type that implements Element.

fn into_any_element(self) -> AnyElement

Convert self into a dynamically-typed AnyElement.