Struct WindowGroup 

pub struct WindowGroup {
    pub id: u64,
    pub maximized: bool,
    pub search_active: bool,
    pub focused: bool,
    /* private fields */
}

Fields

id: u64

maximized: bool

search_active: bool

focused: bool

The active group of the active strip, set by the shell each frame. Consumed by the active TileHost, which paints the signal on the window’s own edge/shadow rather than the group drawing a ring around both the tab row and the card.

Implementations

impl WindowGroup

pub fn new( id: u64, tabs_with_content: Vec<(TabDescriptor, TileContent)>, active_id: u64, width: WindowWidth, ) -> WindowGroup

pub fn from_hosts( id: u64, tabs: Vec<(TabDescriptor, TileHost)>, active_id: u64, width: WindowWidth, ) -> WindowGroup

Mount prepared hosts without unwrapping checked component custody.

pub fn width(&self) -> WindowWidth

pub fn set_external_navigation(&mut self, external: bool)

pub fn with_maximized(self, maximized: bool) -> WindowGroup

pub fn set_focused(&mut self, focused: bool) -> bool

pub fn focused(&self) -> bool

pub fn start_spawn_animation(&mut self)

The window was asked for: its slot opens from nothing. What shows inside it meanwhile is its content’s arrival (TileHost).

pub fn stands(&self) -> bool

Whether the window stands on screen: something in it has drawn, or its place is reserved for content still on its way. Only a first frame from this device, inside its frame budget, keeps it off.

pub fn layout_width_px(&self) -> f64

Width the strip must reserve this frame — the spring value while a transition is in flight, otherwise the persisted fraction.

pub fn dest_width_px(&self) -> f64

Width the slot is going to, in the same pixels as Self::layout_width_px. A later usable-basis change does not rewrite an in-flight target, so overflow can use this instead of the current fraction.

pub fn start_closing(&mut self)

pub fn close_was_requested(&self) -> bool

Whether a close was requested of the client and abandoned visually because the client has not exited.

pub fn frame_presented(&mut self)

A frame was presented by a host that never marks this group drawn (super::GroupRow::frame_presented), so the next frame may step the width spring. If a rebuild skipped its step because the token was still spent, nothing has asked for the rebuild that would step it, and the spring would stay where it stopped while the group kept asking for animation frames.

pub fn next_frame(&mut self)

A new frame may step the width spring and rebuild a closing group once more. Called when the group is drawn, and by a row for groups it culled, so an off-screen transition still ends. A step skipped since the last frame asks for the rebuild that takes it, or the spring would stay where it stopped.

pub fn is_closing(&self) -> bool

pub fn close_complete(&self) -> bool

The close has run its course: the window has faded out and its slot has closed. Pruned before the slot is shut, the windows beside it would jump across what was left of it.

pub fn set_fills_display(&mut self, fills: bool)

Tell the group how much of its top edge something overlays now (the desktop’s top bar while it shows over a window reaching under an auto-hiding one), so the window’s bar stands below it. Zero while the desktop’s bar stands above the window; whether a maximized window here fills its display: nothing of the desktop’s stands beside it.

pub fn set_top_overlay_inset(&mut self, inset: f64)

pub fn strip_usable_px(&self) -> f64

pub fn set_strip_usable_px(&mut self, px: f64)

Called by crate::widget::GroupRow::build_layout before each child builds its own node.

pub fn set_alone(&mut self, alone: bool)

Whether this window has its run of the strip to itself. Called by crate::widget::GroupRow::build_layout with Self::set_strip_usable_px; a placed window springs to the width that follows, as when its width is set.

pub fn resolved_width_px(&self) -> f64

pub fn set_edge_highlight(&mut self, edge: Option<WindowEdge>)

Light up (or, with None, put out) the edge of this window a press would resize, once the pointer has rested there for EDGE_HOVER_DWELL. Set by the parent row from super::edge_resize::seam_owner; the window itself never decides.

pub fn edge_highlight(&self) -> Option<WindowEdge>

The edge a drag is moving, else the one a press would resize.

pub fn width_limits(&self) -> WidthLimits

The widths this window may be resized to: the strictest minimum and maximum any of its tabs’ apps states (crate::widget::AppWidget::min_window_width), never below the strip’s floor. Every tab shares the window’s width, so a background tab’s minimum binds as much as the shown one’s.

pub fn begin_edge_drag(&mut self, moving: WindowEdge)

Start an edge drag on this window that moves its moving edge; the other edge holds still on screen. The width is then set live, in whole pixels, by Self::set_live_width until Self::end_edge_drag. Apps learn which edge holds, so a client that has not caught up with a new size yet is drawn against it.

pub fn set_live_width(&mut self, px: f64)

The width an edge drag puts this window at, this frame: whole pixels, as a client’s geometry is, and exactly where the pointer is rather than on the stored fraction’s grid.

pub fn edge_drag_origin_px(&self) -> Option<f64>

The width this window had when its edge drag began.

pub fn end_edge_drag(&mut self, commit: bool) -> f64

End an edge drag. Committed, the width is stored as the share of the strip it landed on and handed to the shell to persist; cancelled (an Escape, focus loss), the window goes back to the width it had. Returns the change in laid-out width the commit itself makes, since the stored share resolves to whole pixels on its own grid.

pub fn share_width(&mut self, w: WindowWidth)

Narrow (or widen) this window to w to share the screen with a window opened beside it, remembering the width it had so that it gets it back once it is alone on the strip again.

pub fn set_width(&mut self, w: WindowWidth)

A committed width: springs from where the window is drawn. Edge drags set widths live instead (Self::begin_edge_drag).

pub fn stamp_pending_width_change(&mut self)

pub fn has_pending_width_change(&self) -> bool

A width change the host has not yet persisted: until it does, its saved width is the old one and must not be reapplied over it.

pub fn take_pending_width_change(&mut self) -> Option<WindowWidth>

The width to persist, as the window holds it: a default width stays the default (so it keeps taking the strip while alone), not the fraction it resolves to.

pub fn take_pending_tab_reorder(&mut self) -> Option<(usize, usize)>

pub fn take_pending_search_open(&mut self) -> Option<SearchHandoff>

pub fn window_search(&self) -> &WindowSearch

pub fn open_search(&mut self, source: MotionSource)

Open the window’s search on the active tab: in place where its app offers a document or a list, else the platform search narrowed to the app (what the control always did).

pub fn open_search_as(&mut self, source: MotionSource, opening: SearchOpening)

Self::open_search as opening asks: for the replace chord, with the replacement holding the keyboard.

pub fn set_tab_window_offer( &mut self, id: u64, offer: Option<WindowOffer>, ) -> bool

What the app of tab id, running in a process of its own, offers the bar’s search and History control, or None (no such app, or it went away). Returns whether that changed.

pub fn open_search_for_app(&mut self, id: u64, opening: SearchOpening) -> bool

The app of tab id, in a process of its own, asked for the window’s search (its Ctrl+F, or its Ctrl+H for SearchOpening::Replace): open it, or give the open one the keyboard. Only the tab the window shows searches. Returns whether it did.

pub fn close_search(&mut self, source: MotionSource)

Close the window’s search: its app stops highlighting or narrowing.

pub fn take_pending_new_tab(&mut self) -> Option<u64>

pub fn take_pending_close_commits(&mut self) -> Vec<u64>

Drain user-initiated close intents for the shell lifecycle owner. Programmatic closes do not enter this queue because their caller has already committed the workspace mutation before starting the fade.

pub fn new_tab_rect(&self) -> Rect

pub fn any_tile_arriving(&self) -> bool

Whether any tab still stands for content whose first frame is not shown, even when another tab of the window has drawn.

pub fn active_host_mut(&mut self) -> Option<&mut TileHost>

pub fn active_host(&self) -> Option<&TileHost>

Read-only twin of Self::active_host_mut — avoids a &mut borrow that would conflict with the frame builder’s own borrows.

pub fn draw_complete_capture( &mut self, scene: &mut Scene, transform: Affine, tr: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, ) -> Option<Rect>

Paint a complete semantic app canvas with the same shared window card and tab decoration as the live group, without changing live layout.

pub fn cancel_tab_drag(&mut self) -> bool

Cancel the tab bar’s gesture while preserving every live tab host.

pub fn take_tab_detach(&mut self) -> Option<(u64, Point)>

Returns (tab_id, release_point) if the user released a drag outside the bar’s own rect. The parent widget hit-tests the release point against sibling bars to find a target.

pub fn take_pending_maximize_change(&mut self) -> Option<bool>

pub fn toggle_maximized(&mut self)

Keyboard/accessibility twin of the frame maximize button.

pub fn detach_tab(&mut self, tab_id: u64) -> Option<(TabDescriptor, TileHost)>

pub fn insert_detached_tab( &mut self, idx: usize, desc: TabDescriptor, host: TileHost, )

The sibling path — splitting into a brand-new group — plays the group-level fade instead, in GroupRow::split_tab_into_new_group, so the two never double up. The new tab is shown at once; until it has drawn, the window keeps showing the tab it showed before, and then cross-fades to it.

pub fn reorder_tab(&mut self, from: usize, to: usize) -> bool

Move an existing tab to a persisted order without producing a user-gesture one-shot. The tab bar and content hosts are parallel vectors, so a document-driven reorder has to move both or the pill and visible application diverge.

pub fn from_detached( id: u64, desc: TabDescriptor, host: TileHost, width: WindowWidth, ) -> WindowGroup

pub fn tab_count(&self) -> usize

pub fn bar_rect(&self) -> Rect

pub fn tab_rects(&self) -> &[Rect]

pub fn bar_grab_hit(&self, p: Point) -> bool

True inside the bar rect but not on a tab pill and not in the right-edge resize band. Used by GroupRow to arbitrate a press into a group-reorder drag vs. a tab/resize gesture.

pub fn carry_grab_hit(&self, p: Point) -> bool

Where the window can be carried by its bar while it stands on a canvas: anywhere on the bar that is not a control, its title and location included. The resize edge and the search control are not.

pub fn set_carriable(&mut self, carriable: bool)

Whether the window can be carried by its bar from its title and location (Self::carry_grab_hit): it stands on a canvas.

pub fn cancel_press_for_carry(&mut self)

The press on the bar became a carry of the window.

pub fn touch_grab_hit(&self, p: Point) -> bool

Where a finger can grab the whole group: anywhere on its tab bar, tabs included, except the new-tab button and the resize edge.

pub fn resize_grab_hit(&self, p: Point) -> bool

True when p is in the group’s trailing-edge resize target. GroupRow uses this before arming a whole-group drag so the two gestures cannot race; this matters especially for a one-group strip, where this grip is the only resize affordance.

pub fn handle_edge_input( &mut self, event: &WindowEvent, scale_factor: f64, modifiers: Modifiers, ) -> bool

The group’s own pointer chrome (maximized controls, pin shortcut), ahead of its tab bar and tile. The row offers every group this before any group’s tile sees the event: a tile that swallows pointer events (one still loading, or whose record is gone) must not leave another group’s chrome stale.

pub fn resize_grab_rects(&self) -> Vec<Rect>

Both edge zones, leading first: where a press resizes a window rather than reaching its app. Which window it resizes is the row’s to say (super::edge_resize::seam_owner). Empty while maximized or fullscreen.

pub fn leading_resize_grab_rect(&self) -> Option<Rect>

Leading-edge zone, the mirror of Self::resize_grab_rect: the same width, inside the window.

pub fn resize_grab_rect(&self) -> Option<Rect>

Painted trailing-edge grip, shared with compositor input admission.

pub fn drop_index_for(&self, release_point: Point) -> usize

pub fn update_tab_descriptor(&mut self, descriptor: TabDescriptor) -> bool

Update chrome metadata without replacing the document/component owner.

pub fn set_tab_toolbar( &mut self, id: u64, toolbar: Option<WindowToolbar>, ) -> bool

Show the slots tab id’s app declared for the window’s bar (crate::window_toolbar), or none. Returns whether that changed.

pub fn tab_toolbar(&self, id: u64) -> Option<&WindowToolbar>

The slots tab id shows in the bar.

pub fn take_toolbar_events(&mut self) -> Vec<(u64, ToolbarEvent)>

What the person did with the apps’ slots in the bar, by tab.

pub fn take_location_drafts(&mut self) -> Vec<(u64, ToolbarEvent)>

What the edited location held since the last call, by tab, for the app’s suggestions.

pub fn editing_location(&self) -> bool

Whether the active tab’s location is being edited in the bar.

pub fn location_event( &mut self, event: &WindowEvent, ctx: &mut EventCtx<'_>, ) -> bool

Hand a keyboard or text event to the location field while it is edited; the shell routes the keyboard here while Self::editing_location. Returns whether the field took it.

pub fn bar_tooltip_at(&self, p: Point) -> Option<(Rect, String)>

What the button of the window’s bar at p does, for its tooltip.

pub fn draw_bar_popups( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, )

Paint the bar’s top layer (its slots’ menus, the overflow’s and the suggestions, and the search’s options), for a host that draws the windows’ top layer itself.

pub fn location_hit(&self, p: Point) -> bool

Whether p is on the edited location or the suggestions under it: a press there keeps the edit.

pub fn cancel_location_edit(&mut self) -> bool

End the location’s edit, putting it back. Returns whether it was being edited.

pub fn location_rect(&self) -> Rect

Where the active tab’s location stands in the bar.

pub fn edit_location(&mut self) -> bool

Turn the active tab’s editable location into a field (Ctrl+L).

pub fn begin_tab_rename(&mut self, id: u64, name: &str) -> bool

Name tab id in place: its title becomes a field in its pill (crate::widget::TabBar::begin_rename); name is what a reader announces the field as. Returns whether the edit is open.

pub fn renaming_tab(&self) -> Option<u64>

The tab being named in place, if any.

pub fn tab_rename_hit(&self, p: Point) -> bool

Whether p is on the name field of a tab being named.

pub fn tab_rename_event( &mut self, event: &WindowEvent, ctx: &mut EventCtx<'_>, ) -> bool

Hand a keyboard or text event to the name field while a tab is being named; the shell routes the keyboard here while Self::renaming_tab. Returns whether the field took it.

pub fn commit_tab_rename(&mut self) -> bool

Commit the name being edited, as Enter does. Returns whether a tab was being named.

pub fn cancel_tab_rename(&mut self) -> bool

Put the title back, as Escape does. Returns whether a tab was being named.

pub fn take_tab_rename(&mut self) -> Option<(u64, String)>

A name committed in place since the last call: the tab, and the name (empty when the person cleared it).

pub fn tabs(&self) -> &[TabDescriptor]

pub fn set_tab_holder(&mut self, id: u64, holder: Option<TabHolder>) -> bool

Mark tab id as held by someone else (crate::widget::TabHolder), or clear the mark: such a tab offers no close and resists a drag. true when that changed what the window offers.

pub fn set_new_tab(&mut self, on: bool) -> bool

Offer the new-tab control, or not, for someone who opens nothing here. true when that changed what the window offers.

pub fn activate_desktop_control(&mut self) -> bool

Press the bar’s “Controls your desktop” chip without a pointer, as an assistive technology does. Whether the bar shows it.

pub fn take_desktop_control_press(&mut self) -> Option<(u64, Rect)>

A press on the bar’s “Controls your desktop” chip, once: the tab and where the chip stands, for the host’s menu.

pub fn is_held(&self) -> bool

Whether someone else holds any of the window’s tabs, so it does not move as a whole.

pub fn set_tab_attention(&mut self, id: u64, attention: bool) -> bool

Mark tab id as waiting for the person, or not. true when that changed what it paints.

pub fn set_tab_icon(&mut self, id: u64, icon: Option<AppImage>) -> bool

Replace tab id’s artwork. true when that changed what it paints.

pub fn active_tab_id(&self) -> u64

pub fn presentation_bounds(&self) -> WindowGroupBounds

Layout bounds and the control targets cached by production paint. A missing target means it is not currently painted.

pub fn active_maximize_rect(&self) -> Option<Rect>

Painted maximize target for the active tab, if that tab currently has one. This is immutable presentation geometry used by accessibility and optional developer diagnostics.

pub fn take_tab_activation(&mut self) -> Option<u64>

Drain an explicit user selection from the tab bar. Model-driven set_active_tab calls never create this edge.

pub fn set_active_tab(&mut self, id: u64) -> bool

The bar’s active_id is the authoritative copy (the shell flushes it into the persisted tree after input), so a programmatic focus jump must land here, not only in the tree.

pub fn take_tab_context_menu(&mut self) -> Option<(u64, Point)>

pub fn request_close_tab(&mut self, tab_id: u64) -> bool

Drains the bar’s pending_close immediately rather than waiting for the next handle_event, since a menu pick arrives outside pointer dispatch and would otherwise leave the host un-faded until an unrelated event landed.

pub fn cancel_tab_close(&mut self, tab_id: u64) -> bool

Retain the native client while its host awaits actual close admission. The live host and tab metadata survive the provisional close animation.

pub fn drag_in_flight(&self) -> bool

pub fn dragged_tab(&self) -> Option<u64>

The tab this group’s bar is dragging, while it drags one.

pub fn edge_resize_in_flight(&self) -> bool

Whether one of this group’s edges is being dragged to resize it.

pub fn set_external_drag_hover(&mut self, cursor: Option<Point>)

A no-op while the bar has its own pending_drag in flight, so the source bar’s own indicator stays put.

pub fn bar_mut_for_tests(&mut self) -> &mut TabBar

crates/session/session/tests/ integration tests need this from outside the crate, as do its unit tests in an optimised profile.

pub fn close_rect_for_tests(&self, tab_id: u64) -> Option<Rect>

pub fn bar_for_tests(&self) -> &TabBar

pub fn host_for_tab_mut(&mut self, tab_id: u64) -> Option<&mut TileHost>

Detaching and re-inserting would do the same job plus three things nobody asked for: activate the tab, play the arrival fade, and move it to the caller’s index.

pub fn content_rect_for_tab(&self, tab_id: u64) -> Option<Rect>

Laid-out content bounds for a tab. Shell-owned system windows use this as their ordinary tile viewport instead of inventing separate floating geometry.

impl WindowGroup

pub fn set_fullscreen_bar_revealed( &mut self, revealed: bool, source: MotionSource, )

Show or hide a fullscreen window’s bar over it (the host reads the top edge for it, top_edge_reveal); nothing while not fullscreen. source is what showed or hid it: the pointer’s reach fades it, a key or an action (entering fullscreen by Super+F, Super alone) lands it at once.

Trait Implementations

impl ActionControls for WindowGroup

fn has_pending_control_invocation(&self) -> bool

Local control intent queued behind asynchronous startup preparation. A scheduling hint only; the host still checks live authority.

fn install_control_custody( &mut self, domain: &ControlDomain, attachment: CustodyAttachment, )

Bind retained producers before their first callback. Private holders must override this; child traversal alone never certifies full coverage.

fn take_control_invocation(&mut self) -> Option<ControlInvocation>

Drain one queued action-bound control intent from this subtree.

fn take_attributed_control_invocation( &mut self, ) -> Option<(ControlInvocation, Option<InvocationId>)>

Self::take_control_invocation, with the effect invocation the intent continues when an effect’s handler or completion queued it: the host applies it for that invocation’s invoker.

fn on_control_invocation_result( &mut self, address: &ActionAddress, result: &Result<ResourceOperationStart, DoorError>, )

Report the admission result of one queued local control invocation. Accepted means queued, not completed; confirmation remains an error while the host offers its normal confirmation UI. This notification grants no document authority and must not retry the invocation itself.

fn control_action_bindings(&self) -> Vec<ControlBindingMetadata>

Inventory action-native and explicitly legacy controls. A widget that owns an emitter prepends its metadata to its descendants’ inventory.

fn action_control_bindings(&self) -> Vec<ControlBindingMetadata>

Action-emitter bindings in the same order and exposure as the full inventory. Custom private inventories keep their authoritative default; wrappers can avoid allocating semantic-only accessibility snapshots.

fn has_action_control_bindings(&self) -> bool

Whether this exposed subtree contains controls consuming action availability. An override must match whether control_action_bindings contains an Action, including the same modal child exposure, regardless of current availability.

fn refresh_control_action_availability( &mut self, allowed: &HashSet<ActionAddress>, )

Push the fresh local permission-filtered action surface into every retained control: refresh this widget’s own emitter, then its children.

impl CollaborationTopology for WindowGroup

fn collaboration_children_mut(&mut self) -> Vec<&mut dyn Widget>

impl ComponentLifecycle for WindowGroup

fn unsaved_documents(&self, doc: &AutoCommit) -> Vec<UnsavedDocument>

App-declared external document obligations. An in-memory record set is not evidence that an editable file has been saved.

fn checkpoint_components(&mut self) -> Vec<String>

Non-destructive persistence checkpoint. Never closes a wake scope or removes a tree; a failed host close must leave every child usable.

fn finish_admitted_close(&mut self) -> Vec<ComponentCloseReport>

Only the host may call this after every checkpoint succeeded, without dispatching another document mutation in between.

fn close_components(&mut self) -> Vec<ComponentCloseReport>

Capture and close nested components before removing their live trees, transferring all recovery reports to the caller.

fn take_component_close_reports(&mut self) -> Vec<ComponentCloseReport>

Drain inert close-report ownership once; never invoke ordinary app callbacks through a closed component.

fn on_window_close_requested(&mut self) -> WindowCloseAdmission

Admit or defer the primary native window’s ordinary close request. Roots that defer must later produce a one-shot close intent.

fn take_window_close_intent(&mut self) -> bool

One-shot approval after an earlier deferred ordinary window close.

fn take_replacement(&mut self) -> Option<ComponentReplacement>

The component this root’s own component asked to show in its place (AppComponent::take_replacement), for the host that mounted it. A component nested deeper answers to the host that mounted it, so the default reaches no child.

fn take_save_status_presentation(&mut self) -> bool

One-shot: the durability of this root’s own component’s record changed since this was last asked, and the root already synced with the new state. A host that asks (an App) presents it with a frame of its own, not a rebuilt tree; one that does not ask sees it through take_structure_dirty.

impl FloatingSurfaceProvider for WindowGroup

fn on_floating_surface_focus_changed(&mut self, id: Option<&str>, focused: bool)

Route native keyboard focus to the exact presentation instance.

fn on_floating_surface_ime_source_changed(&mut self, id: Option<&str>)

Keep the exact secondary presentation’s editor logically focused while the platform deliberately retains text-input focus on its source. A host-authenticated input route, not a claim by the app; the host clears it when the continuation ends or no longer validates.

fn on_floating_surface_event_source(&mut self, id: Option<&str>)

Identify the native surface delivering the current input event. The host resets this immediately after dispatch; it grants no authority.

fn floating_surface_event( &mut self, id: &str, event: &WindowEvent, ctx: &mut EventCtx<'_>, ) -> bool

Deliver one input event aimed at the card id, in the desk’s coordinates: the frame the card’s hits were recorded in. Answers whether the card took the event.

fn floating_surface_accessibility(&self, id: &str) -> Option<AccessNode>

The retained semantic subtree presented in one secondary window.

fn perform_floating_surface_accessibility_action( &mut self, id: &str, target: &str, action: &Action, state: &mut Edits<'_>, path: &ExId, ) -> bool

fn floating_surface_ime(&self, id: &str) -> Option<(InputContent, Rect)>

IME content type and desktop-logical caret rect for one secondary window.

fn take_floating_surface_request(&mut self) -> Option<FloatingSurfaceRequest>

One-shot request to hand app content to the shared floating-surface host. Shell and in-app hosts consume the same description, so PiP does not require a second rendering/widget API.

fn take_capture_studio_request(&mut self) -> Option<CaptureMode>

One-shot request for the session shell’s shared capture/PiP chooser.

fn take_floating_surface_source_updates(&mut self) -> Vec<(String, Rect)>

Rising-edge source-geometry updates for an adopted floating surface.

fn draw_floating_surfaces( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, )

Paint app-owned content whose presentation has moved into shell space.

fn draw_floating_surface( &mut self, id: &str, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, ) -> bool

Paint exactly one app-owned presentation into its native window. Native secondary windows are independent buffers: painting the plural overlay pass into each would duplicate sibling surfaces and let content escape the window’s own clip.

fn set_floating_surface_bounds(&mut self, bounds: Rect)

Push the shell’s authoritative combined-output bounds into the owner.

fn floating_surface_presentations(&self) -> Vec<FloatingSurfacePresentation>

Desktop-space presentations that need a native secondary window.

fn active_floating_surface_ids(&self) -> Vec<String>

Stable IDs whose underlying activity still exists.

fn on_floating_surface_host_message( &mut self, message: &FloatingSurfaceHostMessage, )

Deliver an acknowledged shell lifecycle edge back to the owner.

impl Widget for WindowGroup

fn perform_semantic_action( &mut self, target: &str, action: &Action, state: &mut Edits<'_>, path: &(dyn Any + 'static), ) -> bool

A node of the bar’s, activated: a tab’s pill switches to that tab, a window control does what it shows.

fn draw_overlay( &mut self, scene: &mut Scene, transform: Affine, text_renderer: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, )

The window’s top layer: its app’s, then its bar’s menus over it, maximized or not.

fn for_each_layout_child(&self, visitor: &mut dyn FnMut(&dyn Widget)) -> bool

The bar and its search as well as every tab’s host.

fn holds_frame_until(&self, now: Instant) -> Option<Instant>

Only what the active tab shows holds the frame: a tab beside it, still starting, never does.

fn presented(&self) -> bool

Any, not all: a group with one live window and a second still starting must not blink out because a sibling tab hasn’t drawn.

fn tooltip_target_at(&self, point: Point) -> Option<(Rect, String)>

The window’s bar is part of the window: what a person rests the pointer on there names itself, its tabs as the whole of their titles where the pill cuts them.

fn cursor_shape(&self, point: Point) -> Option<CursorIcon>

Mirrors the inter-group crate::widget::ResizeHandle so both affordances give the same feedback.

fn take_structure_change(&mut self) -> StructureChange

A change the active tab’s content carries out in place stays in place; the window’s own changes rebuild.

fn remount_children(&mut self, remount: &mut Remount<'_>) -> bool

Carry out a change in place outside a row: as in one, and the window sets its own node’s style.

fn is_layout_dirty(&self) -> bool

Layout follows the built tree: the tab bar (whenever it was built) and the active host. Inactive hosts have no taffy nodes until they are selected, which is a structural change, so their dirtiness must not keep the group re-measuring; the default would walk for_each_child and include them.

fn provide<'a>(&'a self, request: &mut Request<'a, '_>)

Answer a request for a capability this widget takes part in (see capability). Declare capabilities with crate::provides!.

fn provide_mut<'a>(&'a mut self, request: &mut RequestMut<'a, '_>)

Exclusive counterpart to Widget::provide.

fn keyboard_input_scope(&self) -> Option<u64>

Exact app instance whose non-text shortcuts this subtree owns when activation has no control target. Unbound desktop chrome may declare the active tab; component boundaries default to their captured owner.

fn primary_vertical_scroll(&self) -> Option<PrimaryScrollRegion>

Explicit app-owned region; never search secondary children implicitly.

fn apply_primary_vertical_scroll( &mut self, action: PrimaryScrollAction, ) -> PrimaryScrollResult

fn modal_capture(&self) -> Option<Rect>

Some(rect) when this subtree holds an open modal, its panel box. While any widget reports Some, the host suppresses its own global focus shortcuts and swallows unhandled pointer presses so nothing behind the modal is clickable. Containers MUST forward (the default does, via first Some among children).

fn next_wake_deadline(&self) -> Option<Instant>

Earliest wall-clock deadline at which this subtree needs a sync or redraw with no input: the loop sleeps until then (not animation).

fn set_platform_conventions(&mut self, conventions: PlatformConventions)

Receive host-selected platform conventions. The default propagates to retained children, keeping target-OS branches out of app code.

fn set_interaction_environment(&mut self, environment: InteractionEnvironment)

Receive the host’s current input capabilities. The default propagates through retained containers, so app code does not need device branches.

fn mount_native_views(&mut self, host: &NativeViewHost<'_>)

Attach native child views through this owner’s retained lifecycle topology. Presentation containers with inactive or hidden live descendants override this traversal so lifecycle ownership stays independent of drawing and input visibility.

fn unmount_native_views(&mut self)

Tear native children down while their parent window still exists.

fn native_view_frame_start(&mut self)

Begin a native-view frame through this owner’s retained lifecycle topology.

fn children(&self) -> Vec<&dyn Widget>

fn children_mut(&mut self) -> Vec<&mut dyn Widget>

fn for_each_child(&self, visitor: &mut dyn FnMut(&dyn Widget))

Allocation-free read-only child traversal. Existing custom containers inherit a compatibility adapter over Self::children; toolkit containers override this to walk their retained storage directly.

fn sync(&mut self, s: &(dyn Any + 'static), p: &(dyn Any + 'static))

Pull model state into this widget before layout. The default syncs the children Widget::children_mut returns; a widget overrides it only to read state of its own, or to sync children it does not expose there.

fn update(&mut self, s: &(dyn Any + 'static), p: &(dyn Any + 'static)) -> bool

Notice, between frames, state outside the document (a chrome revision, a momentum scroll still ticking) and report whether anything changed. The default updates every child Widget::children_mut returns without short-circuiting, so a container never freezes its descendants; an override checks state of its own and forwards.

fn build_layout( &mut self, taffy: &mut TaffyTree, theme: &Theme, node_map: &mut HashMap<NodeId, *mut dyn Widget>, ) -> NodeId

fn apply_layout(&mut self, taffy: &TaffyTree, node: NodeId, origin: Point)

Take the geometry layout gave this node. The default keeps none, for widgets that neither draw nor hit-test.

fn draw( &mut self, scene: &mut Scene, transform: Affine, tr: &mut TextRenderer, theme: &Theme, presence: &PresenceCtx, )

Paint into scene. The default paints nothing.

fn handle_event(&mut self, event: &WindowEvent, ctx: &mut EventCtx<'_>)

Handle one input event with the runtime services for this retained node.

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

fn get_rect(&self) -> Rect

The rectangle this widget occupies. The default, for widgets that keep no geometry, is empty.

fn wants_pointer_capture(&self) -> bool

fn take_structure_dirty(&mut self) -> bool

True if this subtree’s structural composition changed since the last frame; reading clears it. The default drains every retained child and reports whether any was dirty.

fn needs_redraw(&self) -> bool

Default false (clean). A widget is clean until something it reads changes: a leaf that keeps state says so by tracking a dirty: bool (set in handle_event/sync, cleared in mark_drawn()), and one that paints from the people on the document reads the frame’s presence (crate::presence::frame::frame). Containers MUST forward: dirty iff any descendant is.

fn mark_drawn(&mut self)

Called after this widget’s scene lands in the composed frame, to clear a dirty flag. Default forwards to children.

fn layout_needs_measure(&self) -> bool

Whether a layout_dirty frame needs taffy to re-solve sizes (compute_layout) rather than just reposition already-solved boxes. Scrollable is the motivating override: it translates its origin in apply_layout without changing any taffy size, so re-solving on every scroll frame is pure waste.

fn has_pending_visual_work(&self) -> bool

Work already requested by this view whose completion will replace a placeholder. Unlike animations, this can be awaited by still captures.

fn animation_detail(&self) -> Option<String>

Why this widget itself asks for animation frames, for diagnostics that name a desktop which keeps painting. None when it has nothing to add to its name and geometry.

fn needs_animation_frame(&self) -> bool

App polls this in Event::AboutToWait; without it a curve would freeze until an unrelated event woke it.

fn native_input_snapshot( &self, _state: &(dyn Any + 'static), _path: &(dyn Any + 'static), ) -> Option<Value>

Read-only state evidence for opt-in scheduled native input diagnostics. Called only around diagnostic inputs, never during ordinary input or paint. Keep this inexpensive and root-local; snapshots may be logged verbatim. This verifies widget state, not rendered pixels or display presentation.

fn view_only_scroll(&self, _event: &WindowEvent) -> bool

Opt in only when this wheel event changes scroll geometry and nothing else: no document edit, focus or selection, action availability, resource declaration, pending command or work that requires sync. The runner still lays out, paints and refreshes accessibility geometry; unknown handlers stay on the full path.

fn callback_binding(&self) -> Option<CallbackBinding>

Runtime binding inherited by descendants in a matching layout topology.

fn has_separate_document_owner(&self) -> bool

Whether this widget introduces a document owner distinct from the runner’s outer State. This is a compatibility check, never identity or authority for history access or restore.

fn history_owner(&self) -> Option<HistoryOwner>

Opaque actual custody for framework History source registration.

fn record_owners(&self) -> Vec<HistoryOwner>

Records this widget keeps open beside the document it shows, each synced on its own route: a framework app’s records in the person’s own workspace (crate::record::person). They take no part in this widget’s history or controls.

fn set_window_bar_control(&mut self, in_bar: bool)

Tell this widget whether it stands in a window bar. A bar’s controls are drawn at the bar’s control height whatever the pointer; the target a finger needs reaches beyond the drawn shape, invisibly. The default propagates to children.

fn settle(&mut self, edits: &mut Edits<'_>, path: &ExId)

Apply, after the sync pass, what the widget took up there and must write: a worker’s answer, a chooser’s file, an event a child queued. Writes go only through typed actions on edits; the host syncs again when the document changed. The default settles the returned children.

fn measure( &mut self, _known: Size<Option<f32>>, _available: Size<AvailableSpace>, _text_renderer: &mut TextRenderer, ) -> Size<f32>

fn layout_info(&self) -> Option<LayoutInfo>

Read-only resolved decisions for widgets with an explicit layout policy. None means the widget has no such policy; ordinary manual widgets remain valid. Values are available after build/settlement and carry real origins.

fn adjust_layout_style( &mut self, _taffy: &mut TaffyTree, _node: NodeId, _text: &mut TextRenderer, ) -> bool

Adjust this node’s style using its allocated size, before final geometry is applied. Return true only when the style changed (or an inherited decision child hooks read). An override may measure its owned children through ordinary references, entering their callback binding when present. Never reenter descendants through the raw node map while borrowing their parent, change topology, or build another layout tree. The shared host solver visits every registered widget, repeats layout at most eight times and skips a frame that does not settle.

fn observe_physical_input(&mut self, _input: PhysicalInput)

Observe this app’s ordinary foreground physical input before framework shortcuts consume it. Keep feedback ephemeral; this is not an input grant.

fn for_each_child_in_clip(&self, visitor: &mut dyn FnMut(&dyn Widget))

The children of Self::for_each_child that may paint inside the layout_clip in effect: what a scroll view’s damage and copy plan need. Every child by default; a long column visits only those near the clip, so a frame costs what is shown, not what the column holds.

fn for_each_hosted_child(&self, _visitor: &mut dyn FnMut(&dyn Widget))

Children this widget keeps in the retained tree but does not route input to: a subtree it does not own and answers the person’s events for itself, like a host drawing another widget’s card over the windows. Inspection, named controls and the accessibility tree walk these after the children Self::children lists, so what is walked there keeps the paths, sibling indices and registry entries it had.

fn test_id(&self) -> Option<&str>

Stable id for the e2e test harness; None falls back to a path-based key. Must be unique across the live tree — the registry resolves on first match, so a duplicate shadows the second occurrence.

fn window_slot(&self, _id: String) -> Option<ToolbarAction>

This control as an action of the window’s bar, sent back as id (crate::window_toolbar::ToolbarAction): a button’s icon and name. None for anything that is not a button.

fn as_any(&self) -> Option<&(dyn Any + 'static)>

Downcast to the concrete widget, for hosts and tests that reach a known widget through dyn Widget. Default None (a widget may borrow and so not be 'static); a widget opts in with Some(self), and a Decorator answers itself.

fn as_any_mut(&mut self) -> Option<&mut (dyn Any + 'static)>

fn stands_for(&self, address: *const ()) -> bool

Whether this widget is the one at address, or stands in the tree for it: a Decorator stands for every widget it wraps, so a scroller drawn inside one is found where the decorator is (crate::scroll_copy::offer).

fn focus_reveal_context(&self) -> Option<Rect>

Context that should remain visible with a focused descendant, such as a form control and its validation message. Opt-in scroll containers use this block when it fits; otherwise they prioritise the control.

fn reveal_descendant(&mut self, target: *const dyn Widget) -> bool

Reveal a newly keyboard-focused descendant inside any enclosing viewport. Containers override this to scroll; ordinary widgets simply recurse toward the target and report whether it was found.

fn test_rects(&self) -> Vec<(String, Rect)>

Named hit rects for widgets that paint several affordances into one rect instead of composing children. Same space as Widget::get_rect; zero-area entries are dropped.

fn child_clip_rect(&self) -> Option<Rect>

Absolute logical clip applied to ordinary children during painting and pointer routing. Inspectors and enclosing scroll regions must respect this boundary instead of treating clipped descendants as visible extent.

fn snap_points(&self, axis: ScrollAxis, out: &mut Vec<f32>)

Offsets along axis that this widget, as a scroll view’s content, offers it to settle on, measured from its own leading edge: a board’s lanes (crate::widget::Board). None leaves a scroller stopping wherever the hand left it.

fn take_action_palette_request(&mut self) -> Option<ActionAddress>

One-shot request to open the host’s action palette directly at a typed resource action. Parameter collection and permission checks remain host policy; widgets only name an address already present in resources().

fn take_search_request(&mut self) -> bool

One-shot request to open the host’s search palette, the same one the platform search shortcut opens. An app’s own search button latches it so search stays one shared host surface rather than an app overlay.

fn claims_raw_touch(&self, _point: Point) -> bool

Opt out of touch-to-pointer emulation for contacts that begin at point (logical coords, same space as Widget::get_rect).

fn touch_claim(&self, _point: Point) -> TouchClaim

What a one-finger contact that begins at point (logical coords) means here, when a drag moves something rather than scrolling.

fn tooltip(&self) -> Option<&str>

Revealed after a dwell over the widget’s rect, via the toolkit’s one tooltip mechanism (crate::widget::tooltip::TooltipHost), hit-tested like cursor_shape so containers need not forward it. An icon-only control should also use this as its accessible name.

fn tooltip_side(&self) -> TooltipSide

Which side of the control its tooltip goes: below by default, beside it for a control in a vertical rail.

fn is_focusable(&self) -> bool

fn is_default_keyboard_focus(&self) -> bool

Preferred control when its app is explicitly activated without a valid saved control. Hosts still enforce visibility, enabled state and scope.

fn set_focus(&mut self, _focused: bool)

fn set_full_bleed(&mut self, _full_bleed: bool)

The window holding this content fills its display (a maximized window): it has nothing beside it to round its corners against or to set it apart from, so content that frames or clips itself to the window’s shape draws edge to edge instead. A client surface drawn that way, last and unclipped, is one the display can scan out directly. Content that frames nothing ignores it.

fn set_invalid(&mut self, _invalid: bool)

The form’s validation verdict for this control, set by Field::with_error: an invalid control edges itself in danger ink and reports invalid to assistive technology. Controls without a field face ignore it.

fn focus_requested(&mut self, target: Option<NodeId>, tree: &TaffyTree)

An explicit runner focus request, after resolving the actual keyboard owner. Retained flags and layout restoration are not user gestures. Containers can observe this to reveal the owning viewport.

fn is_focused(&self) -> bool

fn context_menu_anchor(&self) -> Option<Rect>

The box a context menu opened from the keyboard stands against: the item that has the keyboard, so the menu opens under it rather than under the whole widget. A widget that holds items (a list) answers for the one with the keyboard; None leaves the menu to stand under the focused widget’s own box.

fn wants_tab_input(&self) -> bool

Whether a focused widget owns Tab instead of the host’s focus traversal. This is deliberately opt-in: ordinary form fields and controls retain platform-standard Tab/Shift+Tab navigation, while a code editor or terminal can receive the key for indentation or completion. A widget around the focus may claim it too: a sheet that walks its own controls with Tab.

fn ime_cursor_rect(&self) -> Option<Rect>

Caret rectangle for the platform input method, in window-logical coordinates. Returning Some enables IME for the focused widget and positions its candidate window; non-text controls keep the default None and therefore disable IME.

fn traps_focus(&self) -> bool

While any widget answers true, the host restricts Tab/directional focus to this subtree (wrapping at the ends) and restores the prior focus once it goes back to false. Default false.

fn scopes_keyboard_focus(&self) -> bool

Whether Tab and directional focus travel stay inside this subtree while no trap holds focus: the content of the focused desktop window, so keyboard travel cycles through the app the person is in and never wanders onto the desktop’s chrome (its bars, menus and window titles), which the keyboard reaches through its own shortcuts. Unlike Self::traps_focus it moves no focus when it starts or ends, and pointer input is unaffected. Default false.

fn take_app_activation(&mut self) -> Option<u64>

One-shot (reading MUST clear it): the app instance the person just brought forward (a window they opened, clicked or switched to), whose keyboard focus the host restores, or puts on its default control, so what they type next reaches it. Default forwards the first request found among the children.

fn take_focus_request(&mut self) -> Option<String>

One-shot (reading MUST clear it): the test id of the control this subtree asks to take the keyboard once the runner laid it out, such as the first field of a view a person’s press just opened, so what they type next lands there. The runner focuses it as a press focuses a control, blurring any other; a control it does not find (or that takes no focus) leaves focus where it is. Default forwards the first request found among the children.

fn accessibility(&self) -> Option<AccessNode>

Role, name/description/value, and AccessState. Default None means presentational: the node is skipped and children reparent onto the parent. State must be derived, not stored so it can’t drift from draw; names must already be i18n!-resolved.

fn accessibility_shared(&self) -> Option<SharedAccessNode>

Self::accessibility with its synthetic children shared, for a widget that keeps them between frames: each child it did not change is handed over as the very Arc of the last frame, which the semantic tree takes as unchanged without copying or comparing it.

fn accessibility_hidden(&self) -> bool

Whether Self::accessibility reports this subtree hidden, for a host that asks it of every node to prune focus traversal. Widgets whose node is costly to build (text values, per-block children, a translated name) answer without building it: the focus walk asks every widget in the window on every recomputation. Any override must agree with accessibility(); debug builds check it in the walk.

fn accessibility_root(&self) -> Option<AccessNode>

Self::accessibility’s own node with its children left empty: its role, identity (semantic_key) and state. Focus capture and focus order read only these, for every node on every frame, so a widget whose node carries a large subtree (a document exporting its every block) answers without building it. An override must equal accessibility() with children cleared.

fn synthetic_accessibility_rect(&self, _path: &[usize]) -> Option<Rect>

Geometry for an immediate-mode semantic child from AccessNode::children. The path is its child-index path beneath this widget’s accessibility node. Returning a rect lets AccessKit activation inject the same click as pointer input.

fn focus_synthetic_accessibility(&mut self, _path: &[usize]) -> bool

Move this widget’s own immediate-mode focus to a synthetic semantic child. Retained widgets continue to use the ordinary taffy focus path.

fn accessibility_child_parent(&self, _child_index: usize) -> Option<usize>

Reparent one retained children entry beneath a synthetic child returned by accessibility. The returned index addresses AccessNode::children for this frame. Collections use this to place a real interactive row delegate inside its virtual ListItem/TreeItem instead of exporting a duplicate.

fn accessibility_child_path(&self, child_index: usize) -> Option<Vec<usize>>

Reparent one retained children entry beneath a nested path of synthetic children returned by accessibility.

fn accessibility_represents_child(&self, _child_index: usize) -> bool

Whether one retained children entry is already represented in this widget’s own synthetic accessibility tree, so the bridge must not export it a second time. A host that publishes a child’s semantics itself (to add its own controls inside the same dialog) answers true for that child; assistive technology then sees one copy, not two.

fn lays_out_child(&self, _child_index: usize) -> bool

Whether this widget lays one retained children entry out itself (an Embedded part of a painted page) rather than through the window’s layout, which then gives it no node. The accessibility walk reaches such a child, and every widget inside it, through this widget’s node.

fn accessibility_child_description(&self, _child_index: usize) -> Option<String>

What describes one retained children entry to assistive technology, when this widget holds the words for it: a row’s secondary line is its trailing switch’s description. The bridge sets it as that child’s node’s description unless the child describes itself.

fn perform_action( &mut self, _action: &Action, _key_path: &[u64], _state: &mut Edits<'_>, _path: &(dyn Any + 'static), ) -> bool

Perform an accessibility Action on this widget, or on one of its synthetic accessibility nodes. May mutate the CRDT like handle_event.

fn is_enabled(&self) -> bool

A disabled (false) widget is excluded from focus traversal, must reject input in handle_event, and renders dimmed (see DISABLED_ALPHA).

fn ime_requires_deferred_ack(&self) -> bool

This field needs a host that consumes deferred receipts. Ordinary native Wayland windows must not advertise it until they have that delivery path.

fn ime_refuses_ordinary_commits(&self) -> bool

Ordinary input-method commits (a composing keyboard IME, the on-screen keyboard) cannot reach this field: its text arrives only through deferred receipts (a browser page field), so hosts keep standard text input closed outside a dictation session. A field that needs deferred receipts for dictation but turns an ordinary commit into its own acknowledged edit (Terminal’s native editor) does not refuse them.

fn start_deferred_text(&mut self) -> Option<Receipt>

Begin one bounded deferred session after explicit host consent, preserving the existing original-field fingerprint. This grants no microphone access.

fn commit_deferred_text(&mut self, text: &str) -> Option<Receipt>

A private asynchronous final. None leaves ordinary synchronous IME dispatch to the host. A receipt binds this original field and must be acknowledged before the host releases its private recovery transcript.

fn ime_content(&self) -> Option<InputContent>

The focused widget wants platform text input (Wayland text-input-v3, native IMEs elsewhere). None is intentionally the default: enabling an IME for buttons, canvas tools or games makes the compositor raise an on-screen keyboard over content that cannot accept the committed text.

fn ime_multiline(&self) -> bool

Whether the original focused editor accepts line feeds as text. This is field policy, never inferred from a multiline accessibility presentation. Wrappers inherit only one unambiguous child at their active IME caret.

fn ime_edit_fingerprint(&self, key: &[u8; 32]) -> Option<[u8; 32]>

Opaque local invalidation of deferred input, including selection edits that leave the caret rectangle unchanged. The host supplies an ephemeral secret key; no text or selection is retained in the resulting digest. The default shares the accessibility door and excludes protected or read-only controls. Text controls can override it to avoid cloning text.

fn arrives_from(&self) -> Source

Where this content’s first frame comes from while it has not presented: this device (an app starting here), another device or a host. A frame from this device may hold the window’s first frame up to one frame budget; any other reserves the window’s place and says where it comes from after a while.

fn arrival_progress(&self) -> Option<Progress>

How much of what this content’s first frame waits on has come, when that measures itself (its app downloaded before it starts).

fn arrival_shape(&self) -> SkeletonShape

The shape this content declares for the placeholder standing in for its first frame. Undeclared, the placeholder is the ground alone: nothing guesses what a window will show.

fn text_review(&self) -> Option<(usize, String)>

(caret_byte, text), byte offset on a char boundary. The host diffs this before/after an event so caret-only moves (arrows, Home/End) get announced, not just typing.

fn on_external_event( &mut self, _payload: &str, _state: &mut Edits<'_>, _root: &(dyn Any + 'static), )

Delivers an out-of-band string payload from crate::app::UserEvent::External (e.g. a worker thread streaming output into a status log). Default no-op; the App redraws and re-syncs after dispatch, so mutating state here is enough.

fn on_nav_gesture( &mut self, dir: NavDirection, state: &(dyn Any + 'static), path: &(dyn Any + 'static), ) -> bool

Global back/forward gesture (swipe/edge-pull), recognised by crate::gesture::NavGestureRecognizer and delivered to the whole tree; return true once consumed. Default forwards to children, so a widget that owns history becomes swipe-navigable for free.

fn nav_availability(&self) -> NavAvailability

Which directions Self::on_nav_gesture would consume now. A widget that owns history overrides this beside on_nav_gesture.

fn take_focus_reset(&mut self) -> bool

One-shot (reading MUST clear it) signal to move focus to this subtree’s first focusable widget after the next rebuild. Only consulted under crate::app::App::autofocus_on_structure_change; a wizard raises it on step transitions.

fn take_accessibility_request(&mut self) -> Option<AccessibilityRequest>

One-shot (reading MUST clear it) request to change the window’s accessibility preferences, raised by a control the person used. The host applies it before the next frame. Default forwards the first request found among the children.

fn dev_route(&self) -> Option<RouteSnapshot>

Route history when this widget, or one it contains, is a Router.

fn restore_dev_route(&mut self, route: &RouteSnapshot) -> bool

Put route back. Returns whether a router in this subtree accepted it.

fn appearance_intent(&self) -> Option<AppearanceIntent>

Theme/high-contrast/reduced-motion/scale, polled under crate::app::App::appearance_reconcile — how a settings pane re-themes the running app live without a back-channel. Level-triggered; the App recurses Self::children itself, so containers need not forward it. First Some wins.

fn minimum_window_width(&self) -> Option<f64>

The narrowest this window still works at, in logical pixels: the minimum of its compact layout (a NavShell answers with one column at a time). The host states it to the window system, so the desktop stops a resize there. None: no opinion. The host walks the tree itself (minimum_window_width), so containers need not forward it; the first Some wins.

fn preferred_window_size(&self) -> Option<(f64, f64)>

The whole size this window wants, in logical pixels, when the app is the window’s only content and knows how big it must be: the on-screen keyboard parked to a strip. The host states it as the window’s minimum and maximum, so the desktop shapes the surface to it. None: the window is the user’s and the app lays itself out in whatever it gets.

fn set_motion_reduced(&mut self, reduced: bool)

Apply the effective reduced-motion preference before the host asks this subtree whether it needs another animation frame. The default forwards recursively, making the preference a framework policy instead of an optional convention that every container has to remember to implement.

fn needs_idle_sync(&self) -> bool

Whether sync still needs to run on idle frames without input or collab events — e.g. waiting out a document-adoption grace window.

fn disclosing(&self) -> Option<Disclosing>

While this widget is a band on its way in or out (motion::Disclosure: an in-window banner arriving or leaving), or a content-sized container one moves in, how far what follows it is drawn from where it is laid out. A moving band stands out of the layout; its container places it (Self::place_disclosing) and draws the widgets after it lower by transform, so they move with the band’s edge instead of being laid out again every frame. None at rest (the default).

fn place_disclosing(&mut self, _slot: Rect)

Where a band on its way (Disclosing::Band) stands while it is out of the layout: its slot’s top and width (slot’s height is zero), set by its container after each layout.

fn is_band(&self) -> bool

A band that comes and goes (an in-window banner): when its view stops building it, its column draws it leaving (widget::Disclosing). Its column leaves it out of its identity across rebuilds.

fn note_placement(&mut self, _placement: Placement)

Where a band stands in its column, set by the column after each layout: what it leaves when dropped, so the column a rebuild makes can draw it leaving.

fn serve_deadline(&mut self, _now: Instant) -> bool

A deadline this subtree asked for (Self::next_wake_deadline) is due at now: do the work it was for, and say whether anything changed. The default says it did.

fn dismiss_presented_modal(&mut self) -> bool

Close every modal this subtree presents, as its own way out does (a host whose surface is a modal sheet calls it when the shell takes the sheet down). Whether any was presented; containers forward.

fn presents_modal(&self) -> bool

Whether this subtree presents a modal still drawn (arriving, open or leaving): the counterpart of Widget::dismiss_presented_modal.

fn has_transient_feedback(&self) -> bool

Temporary feedback currently presented, such as a save acknowledgement. Captures may intentionally include it; scene-invariance checks can wait for it to disappear separately from unfinished placeholder work.

fn collect_damage(&self, regions: &mut Vec<Rect>)

Logical-pixel bounds whose visual output differs from the last frame.

fn damage_covers_own_box(&self) -> bool

Whether, after this frame’s draw, this widget’s own Self::collect_damage covers every pixel a relayout changed by moving or resizing its layout box: a host that repaints where moved widgets were and are may then leave this widget’s box to it (its children’s boxes still count). A block editor that grew by a paragraph says where its blocks were and are; the default does not claim it.

fn mark_children_drawn(&mut self)

Rest this widget’s children after a frame drew them, for a widget that keeps its own dirty flag: it clears the flag itself, then calls this.

fn release_scene_cache(&mut self)

Release retained encoded-scene storage in this subtree without marking its visual/model state dirty. Outer caches call this after a successful reuse: while the outer display list is authoritative, keeping byte-for-byte descendant encodings only duplicates memory. A later outer rebuild causes descendants to record/cache normally.

fn composition_follows_allocation(&self) -> bool

Whether this widget composes its children from the size it was last allocated (it reads its own rect while building its layout: a compact layout under a width, a count of columns, an inset from a drawer). A window resize then needs a second composition against the new allocation, as well as the re-solve every resize gets. Widgets that compose independently of their allocation, or that report take_structure_dirty themselves when a new allocation changes what they show, keep the default: a resize re-solves the retained tree in place instead of recomposing all of it.

fn paint_bounds(&self) -> Rect

Everything this widget paints, children included; draw_child skips the draw when it misses the viewport. Override for widgets that paint past their own rect.