Struct StyledContainer 

pub struct StyledContainer { /* private fields */ }

Implementations

impl StyledContainer

pub fn new( layout_style: LayoutStyle, style: impl Fn(Rect) -> RectStyle + 'static, children: Vec<Box<dyn LayoutItem>>, ) -> Result<StyledContainer, LayoutError>

pub fn from_slots( layout_style: LayoutStyle, style: impl Fn(Rect) -> RectStyle + 'static, slots: Vec<ChildSlot>, ) -> Result<StyledContainer, LayoutError>

A styled box whose children are a mix of static widgets and reactive fragments (ChildSlots), reconciled into this box’s own node so they inherit its flex direction/gap — the transparent box-with-a-for path (see Container::from_slots).

pub fn with_opacity( self, opacity: impl Fn() -> f32 + 'static, ) -> StyledContainer

pub fn with_transform( self, transform: impl Fn(Rect) -> Option<[f32; 6]> + 'static, ) -> StyledContainer

Apply an affine transform (rotate/scale/translate) to the whole box each view(). The closure takes the laid-out rect and returns the 2×3 matrix, or None for identity.

pub fn on_hover_style( self, f: impl Fn(Rect) -> RectStyle + 'static, ) -> StyledContainer

Paint the box with f while the mouse hovers it (a declarative style swap, like Button). Hover is mouse-only; touch never sets it, so a tap leaves no stuck hover state.

pub fn on_active_style( self, f: impl Fn(Rect) -> RectStyle + 'static, ) -> StyledContainer

Paint the box with f while a primary pointer is held down inside it — the pressed / CSS :active state, which takes precedence over on_hover_style. Unlike hover it tracks touch as well as mouse, and it clears on release, on leaving the box, or once the press drags off, so it never sticks.

pub fn on_press(self, f: impl Fn() + 'static) -> StyledContainer

Make the box itself pressable. The callback fires on a tap (release, not press) inside the box; a child widget that handles the press wins, and a scroll gesture started on the box does not fire it.

pub fn on_alt_press( self, f: impl Fn(PointerButton) + 'static, ) -> StyledContainer

Fire f(button) on a tap with a non-primary button — Secondary (right) or Auxiliary (middle). Same tap-on-release semantics as Self::on_press: a child that handles the press wins, and travel past the tap slop cancels it.

Opt-in per box rather than folded into on_press, because a non-primary press otherwise falls through to whatever is behind it — silently swallowing right-clicks on every pressable box would break that.

pub fn on_long_press(self, f: impl Fn() + 'static) -> StyledContainer

Fires once a press inside the box is held past ~500ms without moving past the tap slop, instead of on_press’s tap-on-release. There is no dedicated timer in the gesture pipeline, so the threshold is only checked on the next pointer event after the press (a move or the release) — it fires slightly late, never at exactly 500ms, and a release before that next check-in is a normal tap.

pub fn on_drag_end(self, f: impl Fn(f32, f32) + 'static) -> StyledContainer

Make the box draggable. The callback fires with the pointer position (layout space) on a press inside the box and on every move until release — even after the pointer leaves the box. Map the coordinate to a value (slider) or an offset (reorder/resize). Fires once when a drag started on this box ends, with the position it finished at (layout space, local to the box, same as on_drag).

This is what makes a threshold gesture expressible: on_drag alone reports where the pointer is but never that it let go, so a swipe-to-dismiss or a drag-to-open can be tracked and never decided. A drag also ends when the pointer leaves the window or a child consumes the release; those carry no position, so the last one the drag reached is reported instead — the gesture always ends exactly once.

pub fn on_drag(self, f: impl Fn(f32, f32) + 'static) -> StyledContainer

pub fn on_hover(self, f: impl Fn(bool) + 'static) -> StyledContainer

Fire f(true) when the mouse enters the box and f(false) when it leaves (mouse only). Independent of on_hover_style: a box can observe hover without swapping its paint.

Registers the box as a pointer target, like on_scroll does for the same reason: a surface that carves its input region from its content (a click-through overlay) never receives a move event over a box it left out of that region, so a hover it did not register is a hover it can’t observe.

pub fn on_scroll(self, f: impl Fn(f32, f32) + 'static) -> StyledContainer

Fire f(dx, dy) with the wheel delta while the mouse is over the box — scroll-to-adjust on a control (a volume or brightness chip, a stepper). Deltas are normalised to pixels, matching ScrollArea: a line delta counts as 20px, so one wheel notch is roughly ±60.

Scroll events carry no pointer position, so the box’s hover state is what targets them; this enables hover tracking on its own, without needing an on_hover_style. A scrollable child (a scroll area inside the box) hit-tests first and keeps the event.

pub fn on_key(self, f: impl Fn(&Key) + 'static) -> StyledContainer

Fire f(&key) on every key press. This is a GLOBAL handler (key events reach every widget; there is no per-widget focus), so it suits app-level shortcuts, not focused text entry.

pub fn on_focus(self, f: impl Fn(bool) + 'static) -> StyledContainer

Make the box focusable and fire f(true)/f(false) when it gains/loses keyboard focus. It joins the tab order (Tab/Shift-Tab reach it) and takes focus on tap. Use it to drive a focus ring or to build a custom focusable widget on top of a box.

Trait Implementations

impl Component for StyledContainer

fn view(&self) -> RenderNode

fn on_event(&mut self, event: &Event) -> EventResult

fn debug_name(&self) -> &'static str

Human-readable widget type name for the devtools tree inspector.

impl Drop for StyledContainer

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl LayoutItem for StyledContainer

fn layout_node(&self) -> NodeId