Struct Collapse 

pub struct Collapse<M> { /* private fields */ }

A section that folds to its header.

The widget is the header — title, chevron, the toggle — and the node it sits on hosts the body as ordinary children below the header strip, the way Panel hosts children. Collapsing is the node’s height animating between the header alone and the full section; the body needs no hiding, because the node’s own clip crops it, mid-animation included.

let section = ui.add(stack, Collapse::new("Nettverk", Msg::Network), rect)?;
// body children of `section`, placed below Collapse::header_height
// ...
match message {
    Msg::Network(open) => widgets::set_open(&mut ui, section, open, FOLD_MS),
}

The widget cannot animate its own node — EventCtx deliberately has no tree access — so it emits fn(bool) -> M and the application answers with set_open, which flips the chevron and drives Ui::animate_layout. Inside a Ui::set_stack the siblings follow every frame, which is the whole accordion mechanism; Accordion packages the exclusivity.

The expanded height is remembered, not configured

set_open notes the node’s height at the moment of collapse, so opening returns the section to wherever it really was — a section that grew a row while open comes back at its grown height. The one case with nothing to remember is a section built collapsed: with_expanded_height covers it.

Implementations

impl<M> Collapse<M>

pub fn new(title: impl Into<String>, message: fn(bool) -> M) -> Self

An open section titled title, reporting toggles through message.

pub fn inert(title: impl Into<String>) -> Self

A section that folds and reports nothing, for one the application never reads the state of.

It drives its own height, which the one built with a message does not: a message is the application saying it will answer with set_open, and one without has nobody else to. So a decorative section on a panel folds when pressed and nothing has to be wired to it — which is what a form file wants, since a form file has no application to name.

Accordion is still the way to make a run of them exclusive; it drives them through set_open and works with these too.

pub fn closed(self) -> Self

Starts the section collapsed. Pair with with_expanded_height, since a section that has never been open has no height to remember.

pub fn with_expanded_height(self, height: i32) -> Self

Sets where the first opening goes, for a section built collapsed.

pub fn with_role(self, role: Role) -> Self

Sets the header’s colour role.

pub fn with_style(self, style: TextStyle) -> Self

Sets the title’s font and size.

pub const fn is_open(&self) -> bool

Whether the section is open (or opening).

pub fn header_height(&self, theme: &Theme) -> i32

The header strip’s height: the theme’s field height.

The strip the widget draws and the closed height set_open folds to — one definition, so they cannot drift.

pub fn set_open_silent(&mut self, open: bool)

Flips the open state without emitting or animating — set_open calls this; so can an application restoring saved state before first paint.

pub const fn expanded_height(&self) -> Option<i32>

The remembered expanded height, if any.

pub fn set_expanded_height(&mut self, height: i32)

Remembers where opening should return to.

Trait Implementations

impl<M: Clone> Clone for Collapse<M>

fn clone(&self) -> Collapse<M>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<M: Debug> Debug for Collapse<M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M> Describe for Collapse<M>

const KIND: &'static str = "collapse"

The name a form file uses for this widget. Kebab-case.

const DOC: &'static str = "A section that folds away to its header and opens again."

One line saying what this widget is, for somebody choosing one.

const GROUP: Group = Group::Container

Which shelf of the catalogue this belongs on.

const ICON: &'static Icon

The widget’s glyph: a small portrait of the thing, for a palette to draw beside — or instead of — its name.

const PROPERTIES: &'static [Property]

Every property, in the order an inspector should show them.

fn get(&self, name: &str) -> Option<Value>

The current value.

fn apply(&mut self, name: &str, value: Value) -> Result<(), Mismatch>

Applies a value, reporting only what went wrong.

fn set(&mut self, name: &str, value: Value) -> Result<(), PropertyError>

Applies a value, reporting what went wrong and where.

impl<M: 'static> Widget<M> for Collapse<M>

fn describe(&self) -> Option<&dyn DynDescribe>

This widget’s property description, if it has one.

fn describe_mut(&mut self) -> Option<&mut dyn DynDescribe>

The mutable half of describe.

fn measure(&self, ctx: &mut MeasureCtx<'_>, _offered: Offer) -> Measured

How big this widget would like to be, given what the caller can promise.

fn paint(&self, ctx: &mut PaintCtx<'_>, canvas: &mut Pen<'_>)

Draws into canvas, which is already clipped to this widget’s bounds intersected with the damage region being repainted.

fn on_event(&mut self, event: &Event<'_>, ctx: &mut EventCtx<'_, M>) -> Handled

Reacts to an event routed to this widget.

fn accepts_pointer(&self) -> bool

Returns true if the pointer can hit this widget.

fn focusable(&self) -> bool

Returns true if this widget can take keyboard focus.

fn preserves_focus(&self) -> bool

Returns true if a press on this widget should leave focus exactly where it is.

fn animate(&mut self, now_ms: u64) -> Animation

Advances time-based state. Called only while this widget has asked to animate — see EventCtx::request_animation — and stops being called the moment it answers Wake::Never.

fn snap(&mut self, now_ms: u64) -> Animation

Lands whatever is in flight at its end state, without animating it.