Struct Window 

pub struct Window { /* private fields */ }

A floating panel with a draggable/resizable title bar and a single content child.

Implementations

impl Window

pub fn new( title: impl Into<String>, font: Arc<Font>, content: Box<dyn Widget>, ) -> Self

Create a new window with the given title, font, and content widget.

Default position: (60, 60) with size = (360, 280). Call [with_bounds] to override.

pub fn title(&self) -> &str

Returns the window title as it was passed to Window::new.

pub fn on_raised(self, cb: impl FnMut(&str) + 'static) -> Self

Register a callback fired whenever this window requests a raise (click-to-front or visibility rising-edge from the sidebar). Receives the window title. The demo uses this to feed a shared z-order tracker that gets persisted to disk.

pub fn with_bounds(self, b: Rect) -> Self

pub fn with_font_size(self, size: f64) -> Self

pub fn with_visible_cell(self, cell: Rc<Cell<bool>>) -> Self

pub fn with_reset_cell(self, cell: Rc<Cell<Option<Rect>>>) -> Self

pub fn with_position_cell(self, cell: Rc<Cell<Rect>>) -> Self

pub fn with_maximized_cell(self, cell: Rc<Cell<bool>>) -> Self

Wire the window’s canvas-maximized state into external persistence.

Call after [with_bounds] when restoring saved state so the current bounds become the pre-maximize bounds used by the first layout pass.

pub fn with_margin(self, m: Insets) -> Self

pub fn with_h_anchor(self, h: HAnchor) -> Self

pub fn with_v_anchor(self, v: VAnchor) -> Self

pub fn with_min_size(self, s: Size) -> Self

pub fn with_max_size(self, s: Size) -> Self

pub fn with_constrain(self, constrain: bool) -> Self

pub fn with_gl_backbuffer(self, enabled: bool) -> Self

Opt this window in/out of the generic retained GL-FBO backbuffer. Disabling renders directly into the inherited parent target.

pub fn with_auto_size(self, auto: bool) -> Self

Make the window size itself to the content’s preferred size every frame. Top-left pin: as content grows/shrinks, the title bar stays where it is.

pub fn with_resizable(self, on: bool) -> Self

Toggle user-dragged resize. false hides every edge/corner handle and disables resize hit-tests. Default: true. Matches egui’s Window::resizable(bool).

pub fn with_resizable_axes(self, h: bool, v: bool) -> Self

Fine-grained axis-locking of the resize handles — pass (true, false) for a horizontally-only resizable window, etc. Implies with_resizable(true). Matches egui’s Window::resizable([h, v]).

pub fn with_tight_content_fit(self, on: bool) -> Self

Lock the window’s height to its content’s required height. The user can grab a vertical resize handle but the next layout snaps back — egui’s W4 “no scroll, no clip, no whitespace” contract. Requires the content tree to expose its required height via Widget::measure_min_height; our FlexColumn, Label, TextArea, and Container::with_fit_height all do.

pub fn with_height_floor_to_content(self, on: bool) -> Self

Floor-only variant of [with_tight_content_fit]: refuses to shrink past content but allows the user to pull the window taller (whitespace below). Used for windows whose content includes a flex-fill child like a multiline TextArea — matches egui’s W5 where the TextEdit fills extra height and the user can grow the window further.

pub fn with_vscroll(self, vscroll: bool) -> Self

Wrap the window’s content in a built-in vertical [ScrollView]. Matches egui’s Window::vscroll(true): lets the user shrink the window below content height without the caller having to wrap the content in a ScrollView manually. Eager — happens at builder time so the rest of the layout / event / paint paths see a single child as usual. Has no effect when called with false (matches the default).

Don’t combine with [with_auto_size]: the ScrollView claims its full available height, which would make auto-sizing grow the window to the canvas. egui’s demo never combines the two flags either.

pub fn on_close(self, cb: impl FnMut() + 'static) -> Self

pub fn show(&mut self)

pub fn hide(&mut self)

pub fn toggle(&mut self)

pub fn is_visible(&self) -> bool

Current visibility — honours an optional shared visible_cell when wired (sidebar toggles, programmatic show/hide). The inherent self.visible field is a fallback for windows that aren’t wired to a cell. Must match the Widget-trait impl below so rising-edge detection in layout() observes sidebar toggles.

Trait Implementations

impl Widget for Window

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

External identity for z-order persistence, inspector lookup, etc.

fn needs_draw(&self) -> bool

A collapsed window paints only its title bar — nothing inside the content area is visible, so no child can legitimately request a repaint. Closing (is_visible false) also short-circuits, matching the default trait impl. Without these overrides a cursor blink or hover tween inside a collapsed/closed window would keep the host loop awake despite being invisible.

fn take_raise_request(&mut self) -> bool

Pop this window to the top of the parent Stack when the false→true visibility edge fires (see layout).

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

Clip child painting to the content area (below the title bar). When collapsed bounds.height == TITLE_H so the content rect has zero height, preventing any child from drawing outside the visible title-bar strip.

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

A static name for this widget type, used by the inspector. Default: “Widget”.

fn is_visible(&self) -> bool

Return false to suppress painting this widget and all its children. The widget’s own paint() will not be called. Default: true.

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

Return the earliest wall-clock instant at which this widget (or any visible descendant) wants the next draw. None = no scheduled wake. The host loop turns a Some(t) into ControlFlow::WaitUntil(t) so e.g. a cursor blink fires without continuous polling.

fn bounds(&self) -> Rect

Bounding rectangle in parent-local Y-up coordinates.

fn margin(&self) -> Insets

Outer margin around this widget in logical units.

fn widget_base(&self) -> Option<&WidgetBase>

Direct read access to the widget’s embedded WidgetBase.

fn widget_base_mut(&mut self) -> Option<&mut WidgetBase>

Mutable counterpart of widget_base.

fn h_anchor(&self) -> HAnchor

Horizontal anchor: how this widget sizes/positions itself horizontally within the slot the parent assigns. Default: HAnchor::FIT (take natural content width).

fn v_anchor(&self) -> VAnchor

Vertical anchor: how this widget sizes/positions itself vertically within the slot the parent assigns. Default: VAnchor::FIT (take natural content height).

fn min_size(&self) -> Size

Minimum size constraint (logical units).

fn max_size(&self) -> Size

Maximum size constraint (logical units).

fn properties(&self) -> Vec<(&'static str, String)>

Return type-specific properties for the inspector properties pane.

fn set_bounds(&mut self, b: Rect)

Set the bounding rectangle. Called by the parent during layout.

fn children(&self) -> &[Box<dyn Widget>]

Immutable access to child widgets.

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

Mutable access to child widgets (required for event dispatch + layout).

fn backbuffer_spec(&mut self) -> BackbufferSpec

Unified widget-owned backbuffer request.

fn backbuffer_state_mut(&mut self) -> Option<&mut BackbufferState>

Mutable retained backbuffer state for widgets that request a BackbufferSpec other than BackbufferKind::None.

fn hit_test(&self, local_pos: Point) -> bool

Return true if local_pos (in this widget’s local coordinates) falls inside this widget’s interactive area. Default: axis-aligned rect test.

fn claims_pointer_exclusively(&self, local_pos: Point) -> bool

When true, hit_test_subtree stops recursing into this widget’s children and returns this widget as the hit target. Used for floating overlays (e.g. a scrollbar painted above its content) that must claim the pointer before children that happen to share the same pixels. Default: false.

fn layout(&mut self, available: Size) -> Size

Compute desired size given available space, and update internal layout.

fn paint(&mut self, ctx: &mut dyn DrawCtx)

Paint this widget’s own content into ctx.

fn paint_overlay(&mut self, ctx: &mut dyn DrawCtx)

Paint decorations that must appear on top of all children.

fn finish_paint(&mut self, ctx: &mut dyn DrawCtx)

Called after paint, child painting, and optional overlay painting.

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

Handle an event. The event’s positions are already in local Y-up coordinates. Return EventResult::Consumed to stop bubbling.

fn hit_test_global_overlay(&self, _local_pos: Point) -> bool

Return true when local_pos hits an app-level overlay owned by this widget. Unlike normal hit testing, ancestors may be missed because the overlay is painted outside their bounds.

fn has_active_modal(&self) -> bool

Whether this widget currently owns an app-modal interaction layer.

fn on_unconsumed_key( &mut self, _key: &Key, _modifiers: Modifiers, ) -> EventResult

Handle a key that was not consumed by the focused widget path.

fn is_focusable(&self) -> bool

Whether this widget can receive keyboard focus. Default: false.

fn set_label_color(&mut self, _color: Color)

If this widget is text-bearing (e.g. Label), update its foreground colour. Default is a no-op. Composite widgets call this on their children to retint labels without rebuilding them — used by Button when toggling between active (white text on accent) and inactive (theme text on subtle bg) appearances.

fn set_label_text(&mut self, _text: &str)

If this widget is text-bearing (e.g. Label), update its displayed text. Default is a no-op. Composite widgets that own a Label child use this to push live values (e.g. an FPS counter) into the child without bypassing the standard backbuffered glyph cache — calling this on a Label only invalidates the cache when the text actually changed.

fn as_reflect(&self) -> Option<&dyn Reflect>

Opt-in reflection accessor for the inspector’s typed property editors.

fn as_reflect_mut(&mut self) -> Option<&mut dyn Reflect>

Mutable counterpart of as_reflect. Used by the inspector to write edits back into the live widget.

fn has_backbuffer(&self) -> bool

Whether this widget renders into its own offscreen buffer before compositing into the parent.

fn compositing_layer(&mut self) -> Option<CompositingLayer>

Request that this widget subtree be painted into a transient transparent compositing layer before being blended into its parent.

fn mark_dirty(&mut self)

Mark this widget’s own retained surface dirty, if it owns one.

fn backbuffer_cache_mut(&mut self) -> Option<&mut BackbufferCache>

Opt into per-widget CPU bitmap caching with a dirty flag.

fn backbuffer_mode(&self) -> BackbufferMode

Storage format for this widget’s backbuffer. Ignored unless [backbuffer_cache_mut] returns Some. Default BackbufferMode::Rgba — correct for any widget. Opt into BackbufferMode::LcdCoverage only when the widget paints opaque content covering its full bounds.

fn contributes_children_to_inspector(&self) -> bool

Whether the inspector should recurse into this widget’s children.

fn show_in_inspector(&self) -> bool

Return false to hide this widget (and its subtree) from the inspector node snapshot entirely. Intended for zero-size utility widgets such as layout-time watchers / tickers / invisible composers — they bloat the inspector tree without providing user-relevant information and, at scale, can make the inspector’s per-frame tree rebuild expensive.

fn lcd_preference(&self) -> Option<bool>

Per-widget LCD subpixel preference for backbuffered text rendering.

fn paint_global_overlay(&mut self, _ctx: &mut dyn DrawCtx)

Paint app-level overlays after the entire widget tree has been painted.

fn padding(&self) -> Insets

Inner padding — space the widget reserves between its own bounds and its child layout area. Only container widgets carry padding; leaf widgets default to Insets::ZERO.

fn enforce_integer_bounds(&self) -> bool

Whether paint_subtree should snap this widget’s incoming translation to the physical pixel grid.

fn measure_min_height(&self, _available_w: f64) -> f64

Report the minimum height this widget needs to fully render its content when given the supplied available_w for width.