Struct RhythmOverlay 

pub struct RhythmOverlay { /* private fields */ }

Available on crate feature gpui only.

A draw-rhythms debug overlay: every other grid row in one color. Place it as the last child of the container it should cover; it fills that container and ignores mouse events. An ordinary gpui container already uses relative positioning by default, so no extra .relative() call is needed, and this element does not alter the container’s position style.

The stripes start at the container’s top edge. If the content scrolls a container, put the overlay inside the scrolled wrapper so the grid moves with the text; a renderer that scrolls by painting content at a computed signed Y offset instead passes that same offset to phase. Either way only rows intersecting the visible region (the current content mask) are painted, and each is clipped to the overlay’s own bounds, so covering a document far taller than the viewport costs O(viewport height / grid size) per frame and never paints outside the container it covers. Custom elements whose offset settles during prepaint can call paint with a freshly phased value during their paint stage instead of capturing stale state during render.

Implementations

impl RhythmOverlay

pub fn phase(self, offset: Pixels) -> Self

Translate the stripes by the same signed Y offset used to paint the content, for renderers that scroll without moving a scroll container. A negative offset moves both content and grid origin above the element; a positive offset moves them below it. In particular, ScrollHandle::offset().y can be passed through directly.

This has the effect of translating the overlay with the content — without a wrapper element, and without an ancestor to clip it, since stripes are clipped to the overlay’s own bounds.

Panics

Panics when offset is not finite.

pub fn paint(&self, bounds: Bounds<Pixels>, window: &mut Window)

Paint the configured stripes directly into window within bounds.

This is the paint-stage counterpart to using the overlay as an element. It is intended for custom renderers whose signed content translation is not final until another element’s prepaint has settled layout. Read that application-owned value during paint, apply it to a temporary overlay with phase, then call this method; the crate stores no callback or mutable scroll state.

bounds takes the covered container’s role, which the element form fills in from the parent: stripe row 0 starts at bounds.origin.y plus the phase, and nothing paints outside the box. The current content mask is applied exactly as for the element form, and only visible stripes are visited. Call this after painting the content the stripes should cover.

use gpui::{Bounds, Pixels, Window, px, rgba};
use rhythm_gpui::RhythmGrid;

fn paint_grid(
    bounds: Bounds<Pixels>,
    content_offset_y: Pixels,
    window: &mut Window,
) {
    RhythmGrid::new(px(8.))
        .overlay(rgba(0xff78783f))
        .phase(content_offset_y)
        .paint(bounds, window);
}

Trait Implementations

impl From<RhythmGrid> for RhythmOverlay

A bare grid converts to its default debug appearance — the classic translucent red (0xff78783f), zero phase — which is what lets RhythmStyled::rhythm_debug_overlay accept the grid directly.

fn from(grid: RhythmGrid) -> Self

Converts to this type from the input type.

impl IntoElement for RhythmOverlay

type Element = Component<RhythmOverlay>

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.

impl RenderOnce for RhythmOverlay

fn render(self, _window: &mut Window, _cx: &mut App) -> impl IntoElement

Render this component into an element tree. Note that this method takes ownership of self, as compared to Render::render() method which takes a mutable reference.