Struct PaintCtx 

pub struct PaintCtx<'a> { /* private fields */ }

Context passed to Widget::paint: resolved geometry, frame-request signals that bubble into a PaintOutcome, and root-threaded globals.

Implementations

impl<'a> PaintCtx<'a>

pub const MAX_PACED_INTERVAL: Duration

Ceiling on paced intervals: above every real cadence, far below where the shells’ pacing arithmetic (interval * 2, nanos as u64) overflows.

pub fn new(origin: Point, size: Size) -> PaintCtx<'a>

Create a paint context at origin/size with a zero clock and no theme.

pub fn with_theme(self, theme: &'a (dyn Any + 'static)) -> PaintCtx<'a>

Attach the app’s active theme, type-erased (widget tests).

pub fn with_translucent(self, translucent: bool) -> PaintCtx<'a>

Mark the pass as painting a translucent surface (widget tests).

pub fn with_retained_ledger(self, ledger: &'a RetainedLedger) -> PaintCtx<'a>

Thread a resident-key ledger into the pass (widget tests).

pub fn theme_as<T>(&self) -> Option<&T>

where T: Any,

Recover the theme as &T, or None if absent or of another type.

pub fn window_insets(&self) -> WindowInsets

The window insets for this paint pass.

pub fn with_window_insets<R>( &mut self, insets: WindowInsets, f: impl FnOnce(&mut PaintCtx<'a>) -> R, ) -> R

Run f with insets as the window insets, then restore them; wrapping paint_child hands the override to the whole subtree.

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

The shell’s count of frames actually presented, or None. An FPS meter differences this (wrapping_sub), not its own paint count.

pub fn origin(&self) -> Point

The widget’s absolute window-space origin — the one to anchor overlays and reported rects from (ChildPod::origin is parent-relative).

pub fn size(&self) -> Size

The widget’s resolved size.

pub fn has_focus(&self) -> bool

Whether the widget holds the focus path — authoritative at paint, since a container-routed blur never reaches the widget’s event().

pub fn shortcut_hints(&self) -> Rc<[ShortcutHint]>

The previous paint’s shortcut declarations, as BuildCtx::shortcut_hints returns them; empty on a context its root did not seed.

pub fn is_focused_for_ring(&self) -> bool

Whether to draw a focus ring: PaintCtx::has_focus and the root’s FocusRingPolicy allowing one right now.

pub fn is_hovered(&self) -> bool

Whether this widget or a descendant is on the hover path (CSS :hover). Authoritative: the widget the pointer left gets no event, so a hover consumer self-corrects from this each paint.

pub fn frame_time(&self) -> FrameTime

The shell clock for this frame; only ever difference it against a stored earlier value.

pub fn request_frame(&mut self)

Request another frame because paint advanced animation state (TickClass::Transition).

pub fn request_frame_paced(&mut self)

Request a pacable (TickClass::CosmeticLoop) frame at the theme’s cosmetic_loop_rate.

pub fn request_frame_paced_at(&mut self, interval: Duration)

Request a pacable repaint at most once per interval (a caret blink). Intervals fold to the minimum, so a slow request never starves a fast one; capped at Self::MAX_PACED_INTERVAL.

pub fn request_frame_class(&mut self, class: TickClass)

Request a frame of an explicit TickClass.

pub fn needs_frame(&self) -> bool

Whether a continuation frame was requested during this (sub)paint.

pub fn frame_class(&self) -> Option<TickClass>

The aggregate TickClass requested, or None if no frame was.

pub fn needs_frame_paced_only(&self) -> bool

Whether every frame request was TickClass::CosmeticLoop (paceable).

pub fn paced_interval(&self) -> Option<Duration>

The tightest paced interval named, or None; both mean the theme rate.

pub fn request_layout(&mut self)

Request layout next frame because this paint’s animation changes layout; implies an unpaced Self::request_frame.

pub fn needs_layout(&self) -> bool

Whether a layout re-run was requested during this (sub)paint.

pub fn publish_ime_state(&mut self, state: ImeState)

Publish the focused editable’s IME surface, so an app-driven change that never crosses the event pass still reaches the shell.

pub fn take_ime_state(&mut self) -> Option<ImeState>

Take the IME surface published during this (sub)paint, if any.

pub fn publish_platform_view(&mut self, frame: PlatformViewFrame)

Publish a platform-view slot’s frame (pushed; many slots per pass).

pub fn take_platform_views(&mut self) -> Vec<PlatformViewFrame>

Take (and clear) every platform-view frame published this (sub)paint.

pub fn report_input_shield(&mut self, rect: Rect)

Report an absolute rect where frust content over a platform-view slot keeps winning input (a “z-shield”); the shell differ assigns it to slots.

pub fn take_input_shields(&mut self) -> Vec<Rect>

Take (and clear) every z-shield rect reported this (sub)paint.

pub fn register_overlay(&mut self, entry: OverlayEntry)

Float entry’s pod above the app this frame and register it for input routing. The root paints it after the main tree, so the owner must not; the registry clears each pass, so the owner re-registers every paint.

pub fn register_shortcut(&mut self, decl: ShortcutDecl)

Declare a keyboard shortcut for this frame (see crate::shortcuts). The table clears each paint, so the declarer re-declares every paint; it answers its own InputEvent::Shortcut with Handled.

pub fn publish_selection_toolbar(&mut self, request: SelectionToolbarRequest)

Publish this frame’s focused-field verbs and menu anchor for the platform edit menu. A focused field publishes every paint, so hardware shortcuts stay answerable; no publish means nothing is focused.

pub fn report_hero(&mut self, tag: &str, bounds: Rect) -> HeroDirective

Report a hero’s absolute bounds and read back its directive; a no-op returning HeroDirective::Normal with no reporter installed.

pub fn hero_active(&self) -> bool

Whether a hero reporter is installed (culling containers stop culling).

pub fn with_hero_registry( &mut self, registry: &RefCell<HeroFrames>, f: impl FnOnce(&mut PaintCtx<'_>), )

Run f with registry as the hero reporter; requests and publications inside bubble back onto self.

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

The absolute visible rect for culling, or None (paint everything).

pub fn constrain_visible_rect(&mut self, rect: Rect)

Constrain the visible rect to rect (absolute); nested rects intersect.

pub fn is_translucent(&self) -> bool

Whether the shell surface is translucent (“Mode B”); the hole-punch clears only then.

pub fn paint_serial(&self) -> u64

The serial the root minted for this pass (0 with no root), echoed by the ledger’s frame.

pub fn retained_available( &self, key: RetainedKey, rect_px: Size, scale: f32, recorded_serial: u64, ) -> bool

Whether the renderer holds a page for key at rect_px and scale, per a ledger covering recorded_serial (guarding against a stale ledger).

pub fn subtree_clean(&self, pod: &ChildPod) -> bool

Whether nothing under pod changed since its last paint (ask about the child pod); hover and focus moves bump the paint epoch.

pub fn retained_enabled(&self) -> bool

Whether a boundary may bracket its body (retained layers on, ledger set).

pub fn paint_publications(&self) -> u32

Side-channel publications (IME, platform view, shield, overlay, toolbar, hero) this (sub)paint made; a body that published must not be replayed.