#![forbid(unsafe_code)]
mod app;
mod command;
mod command_history;
mod diagnostics;
mod layout_work;
mod logo;
mod measure_cache;
mod motion;
mod output_cache;
mod output_range;
mod overlay;
mod reactive;
mod resources;
use resources::ResourceStore;
mod widget;
use std::{
collections::{BTreeSet, HashMap, HashSet, VecDeque},
sync::{
Arc,
atomic::{AtomicU64, Ordering},
},
};
use rustc_hash::{FxHashMap, FxHashSet};
use sui_core::{
AsyncWakeToken, Clipboard, ClipboardBackend, CursorGrabMode, CustomEvent, DirtyRegion,
DragEvent, DragEventKind, DragOutcome, DragPayload, DragScopeId, DragSessionId, DropEffect,
DropEffects, Error, Event, FontHandle, ImageHandle, InvalidationKind, InvalidationRequest,
InvalidationTarget, KeyState, KeyboardEvent, Modifiers, Point, PointerButton, PointerButtons,
PointerEvent, PointerEventKind, PointerKind, Rect, Result, SemanticsActionRequest,
SemanticsEvent, SemanticsNode, Size, TimerToken, Transform, UrlOpener, UrlOpenerBackend,
Vector, WakeEvent, WidgetId, WindowEvent, WindowId,
};
use sui_layout::Constraints;
use sui_scene::{
ImageRegistry, LayerCompositionMode, RegisteredImage, Scene, SceneCommand, SceneFrame,
SceneLayer, SceneLayerDescriptor, SceneLayerUpdate, SceneLayerUpdateKind,
};
use sui_text::{FontRegistry, RegisteredFont, TextLayoutHandle, TextSystem};
use web_time::Instant;
pub use app::{Application, EmbeddedSvgImageResource, WindowBuilder, WindowIcon};
pub use command::{
Command, CommandController, CommandCtx, CommandDelivery, CommandKey, CommandSender,
CommandTarget,
};
use command::{CommandInvalidation, CommandListeners, QueuedCommand};
pub use command_history::{COMMAND_HISTORY_LENGTH, window_command_dispatches_signal};
pub use diagnostics::{
CacheMetrics, CacheMetricsDelta, CommandDispatchSample, FramePhase, FramePhaseSample,
InvalidationTraceSample, PresentationLatencyDiagnostics, ReactiveInvalidationSample,
RenderDiagnostics, RendererSubmissionDiagnostics, RetainedPacketHotspotDiagnostics,
RetainedPacketRebuildDiagnostics, SceneStatistics, SceneStatisticsDetailMode,
TextCacheDeltaDiagnostics, TextCacheDiagnostics, WidgetRebuildSample, WidgetTimingPhase,
WidgetTimingSample, WindowColorManagementMode, WindowDynamicRangeMode,
WindowOutputColorPrimaries, WindowPerformanceSnapshot, WindowPerformanceSummary,
WindowRenderOptions, WindowStemDarkening, WindowTextCoveragePolicy, WindowTextHinting,
WindowTextSubpixelOrder, WindowToneMappingMode, clear_window_performance_snapshot,
clear_window_performance_snapshots, clear_window_render_options,
publish_window_performance_snapshot, set_window_render_options,
set_window_scene_statistics_detail_mode, window_performance_snapshot,
window_performance_summary, window_performance_text_caches, window_render_options,
window_scene_statistics_detail_mode,
};
#[doc(hidden)]
pub use layout_work::record_scrollbar_gutter_iteration;
pub use layout_work::{
LayoutWorkSnapshot, begin_layout_work_collection, take_layout_work_collection,
};
pub use logo::{DEFAULT_SUI_LOGO_SVG, default_sui_logo_image};
pub use motion::{
AnimateCtx, FrameClock, FramePacing, Motion, app_motion_preference, motion_policy,
motion_time_scale, reset_motion_settings, set_app_motion_preference, set_motion_time_scale,
set_system_motion_preference, system_motion_preference,
};
pub use output_range::{
OutputColorRange, set_window_output_color_range, window_output_color_range,
window_output_color_range_signal,
};
pub use overlay::{
OVERLAY_DISMISS_REQUEST, OverlayDismissPolicy, OverlayDismissReason, OverlayDismissRequest,
OverlayFocusBehavior, OverlayInitialFocus, OverlayKind, OverlayManagerSnapshot,
OverlayModality, OverlayOptions, OverlaySnapshot, OverlayTraceKind, OverlayTraceSample,
};
use std::rc::Rc;
pub use sui_core::{DpiInfo, MotionPolicy, MotionPreference, SafeAreaInsets};
pub use sui_layout::LayoutContext;
pub use widget::{
ArrangeCtx, EventCtx, EventPhase, FocusRestorePolicy, FocusScope, FocusScopeState,
KeyedChildren, KeyedReconcile, LayerOptions, MeasureCtx, PaintBoundaryMode, PaintCtx,
SemanticsCtx, SingleChild, StackHostOptions, StackOrderPolicy, StackSurfaceOptions, Widget,
WidgetChildren, WidgetDiagnostic, WidgetDiagnosticsCtx, WidgetDiagnosticsSnapshot, WidgetPod,
WidgetPodMutVisitor, WidgetPodVisitor,
};
use widget::{ArrangeScope, MeasureScope};
use widget::{
BeginDragRequest, CursorRequest, DragRequest, DropAcceptanceRequest, FocusRequest,
HostServices, PaintImageResource, PointerCaptureRequest, WakeRequest,
};
pub const REACTIVE_CHANGED: CommandKey<()> = CommandKey::new("sui.reactive.changed");
type PaintOutput = (
Scene,
Vec<(ImageHandle, PaintImageResource)>,
HashMap<WidgetId, Rect>,
Option<Rect>,
);
static NEXT_WINDOW_ID: AtomicU64 = AtomicU64::new(1);
pub const EXTERNAL_WAKE_KIND: &str = "sui.external.wake";
pub struct Runtime {
resources: ResourceStore,
text_system: Arc<TextSystem>,
services: HostServices,
windows: Vec<WindowState>,
external_waker: Option<Arc<dyn Fn() + Send + Sync>>,
command_sender: CommandSender,
command_listeners: CommandListeners,
}
#[cfg(feature = "layout-diagnostics")]
pub fn begin_frame_timing_collection() {
diagnostics::begin_widget_timing_collection();
sui_text::begin_text_timing_collection();
}
impl Runtime {
pub fn new() -> Self {
Self::with_resources(ResourceStore::default())
}
fn with_resources(resources: ResourceStore) -> Self {
Self {
resources,
text_system: Arc::new(TextSystem::new()),
services: HostServices::default(),
windows: Vec::new(),
external_waker: None,
command_sender: CommandSender::new(),
command_listeners: CommandListeners::default(),
}
}
pub fn add_window(&mut self, builder: WindowBuilder) -> Result<WindowId> {
let window_id = self.alloc_window_id();
let mut window = builder.build(window_id, self.command_sender.clone())?;
window.services = self.services.clone();
window.reactive_hub.set_waker(self.external_waker.clone());
self.windows.push(window);
Ok(window_id)
}
pub fn set_external_waker(&mut self, waker: impl Fn() + Send + Sync + 'static) {
let waker: Arc<dyn Fn() + Send + Sync> = Arc::new(waker);
self.external_waker = Some(Arc::clone(&waker));
for window in &self.windows {
window.reactive_hub.set_waker(Some(Arc::clone(&waker)));
}
}
pub fn set_command_waker(&self, waker: impl Fn() + Send + Sync + 'static) {
self.command_sender.set_waker(Some(Arc::new(waker)));
}
pub fn command_sender(&self) -> CommandSender {
self.command_sender.clone()
}
pub fn has_pending_commands(&self) -> bool {
self.command_sender.has_pending()
}
pub fn exit_requested(&self) -> bool {
self.command_sender.exit_requested()
}
pub fn process_reactive_updates(&mut self) {
for window in &mut self.windows {
window.drain_reactive_invalidations();
}
}
pub fn process_commands(&mut self) {
const MAX_COMMAND_ROUNDS: usize = 8;
for _ in 0..MAX_COMMAND_ROUNDS {
let (manual_wake, commands) = self.command_sender.drain();
if !manual_wake && commands.is_empty() {
break;
}
if manual_wake {
self.dispatch_controller_wake();
}
for command in commands {
self.dispatch_queued_command(&command);
}
}
}
pub fn handle_command<T>(
&mut self,
target: CommandTarget,
delivery: CommandDelivery,
key: CommandKey<T>,
payload: T,
) where
T: Send + Sync + 'static,
{
match delivery {
CommandDelivery::Directed => self.command_sender.send(target, key, payload),
CommandDelivery::Broadcast => self.command_sender.broadcast(target, key, payload),
};
self.process_commands();
}
pub fn clipboard(&self) -> Clipboard {
self.services.clipboard.clone()
}
pub fn set_clipboard_backend(&self, backend: impl ClipboardBackend + 'static) {
self.services.clipboard.set_backend(backend);
}
pub fn url_opener(&self) -> UrlOpener {
self.services.url_opener.clone()
}
pub fn set_url_opener_backend(&self, backend: impl UrlOpenerBackend + 'static) {
self.services.url_opener.set_backend(backend);
}
pub fn remove_window(&mut self, window_id: WindowId) -> Result<()> {
let Some(window_index) = self
.windows
.iter()
.position(|window| window.id == window_id)
else {
return Err(Error::new(format!(
"window {} does not exist",
window_id.get()
)));
};
self.windows.remove(window_index);
clear_window_performance_snapshot(window_id);
Ok(())
}
pub fn handle_event(&mut self, window_id: WindowId, event: Event) -> Result<()> {
self.dispatch_event(window_id, event).map(|_| ())
}
pub fn dispatch_event(&mut self, window_id: WindowId, event: Event) -> Result<bool> {
let text_system = Arc::clone(&self.text_system);
let font_registry = Arc::clone(self.resources.fonts());
let image_registry = Arc::clone(self.resources.images());
let window = self.window_mut(window_id)?;
window.drain_reactive_invalidations();
let handled = window.handle_event(event, text_system, font_registry, image_registry);
window.drain_reactive_invalidations();
Ok(handled)
}
pub fn handle_semantics_action(
&mut self,
window_id: WindowId,
target: WidgetId,
action: SemanticsActionRequest,
) -> Result<bool> {
let text_system = Arc::clone(&self.text_system);
let font_registry = Arc::clone(self.resources.fonts());
let image_registry = Arc::clone(self.resources.images());
let window = self.window_mut(window_id)?;
Ok(window.handle_semantics_action(
target,
action,
text_system,
font_registry,
image_registry,
))
}
pub fn tick(&mut self, frame_time: f64) {
for window in &mut self.windows {
window.last_tick_time = frame_time;
}
}
pub fn drain_ready_events(&mut self) -> Vec<(WindowId, Event)> {
let mut ready = Vec::new();
for window in &mut self.windows {
let window_id = window.id;
ready.extend(
window
.drain_ready_events()
.into_iter()
.map(|event| (window_id, event)),
);
}
ready
}
pub fn next_wakeup_time(&self, window_id: WindowId) -> Result<Option<f64>> {
let window = self.window(window_id)?;
Ok(window.next_wakeup_time())
}
pub fn has_pending_animation_frames(&self, window_id: WindowId) -> Result<bool> {
let window = self.window(window_id)?;
Ok(window.active_animated_widget_count() > 0)
}
pub fn set_frame_pacing(&mut self, window_id: WindowId, pacing: FramePacing) -> Result<()> {
self.window_mut(window_id)?.frame_pacing = pacing;
Ok(())
}
pub fn frame_pacing(&self, window_id: WindowId) -> Result<FramePacing> {
Ok(self.window(window_id)?.frame_pacing)
}
pub fn begin_animation_frame(
&mut self,
window_id: WindowId,
frame_time: f64,
) -> Result<Vec<Event>> {
Ok(self
.window_mut(window_id)?
.begin_animation_frame(frame_time))
}
pub fn wake_async(&mut self, window_id: WindowId, token: AsyncWakeToken) -> Result<bool> {
let window = self.window_mut(window_id)?;
Ok(window.wake_async(token))
}
pub fn wake_root(&mut self, window_id: WindowId) -> Result<()> {
self.handle_event(
window_id,
Event::Custom(CustomEvent::new(EXTERNAL_WAKE_KIND)),
)
}
pub fn register_font(&mut self, handle: FontHandle, font: RegisteredFont) -> Result<()> {
self.resources.register_font(handle, font)
}
pub fn register_font_bytes(&mut self, data: impl Into<Vec<u8>>) -> Result<FontHandle> {
self.resources.register_font_bytes(data)
}
pub fn register_image(&mut self, handle: ImageHandle, image: RegisteredImage) -> Result<()> {
self.resources.register_image(handle, image)
}
pub fn register_svg_image_with_handle(
&mut self,
handle: ImageHandle,
data: impl AsRef<[u8]>,
) -> Result<()> {
self.resources.register_svg_image_with_handle(handle, data)
}
pub fn register_rgba_image(
&mut self,
width: u32,
height: u32,
data: impl Into<Vec<u8>>,
) -> Result<ImageHandle> {
self.resources.register_rgba_image(width, height, data)
}
pub fn register_svg_image(&mut self, data: impl AsRef<[u8]>) -> Result<ImageHandle> {
self.resources.register_svg_image(data)
}
pub fn register_svg_image_at_size_with_handle(
&mut self,
handle: ImageHandle,
width: u32,
height: u32,
data: impl AsRef<[u8]>,
) -> Result<()> {
self.resources
.register_svg_image_at_size_with_handle(handle, width, height, data)
}
pub fn register_svg_image_at_size(
&mut self,
width: u32,
height: u32,
data: impl AsRef<[u8]>,
) -> Result<ImageHandle> {
self.resources
.register_svg_image_at_size(width, height, data)
}
pub fn register_embedded_svg_image(
&mut self,
resource: EmbeddedSvgImageResource,
) -> Result<()> {
self.resources.register_embedded_svg_image(resource)
}
pub fn register_embedded_svg_images(
&mut self,
resources: impl IntoIterator<Item = EmbeddedSvgImageResource>,
) -> Result<()> {
self.resources.register_embedded_svg_images(resources)
}
pub fn font_registry(&self) -> &Arc<FontRegistry> {
self.resources.fonts()
}
pub fn text_preparation_cache_snapshot(&self) -> sui_text::TextPreparationCacheSnapshot {
self.text_system.preparation_cache_snapshot()
}
pub fn image_registry(&self) -> &Arc<ImageRegistry> {
self.resources.images()
}
pub fn render(&mut self, window_id: WindowId) -> Result<RenderOutput> {
let text_system = Arc::clone(&self.text_system);
let font_registry = Arc::clone(self.resources.fonts());
let image_registry = Arc::clone(self.resources.images());
let window = self.window_mut(window_id)?;
window.repaint_for_render_options();
window.drain_reactive_invalidations();
Ok(window.render(text_system, font_registry, image_registry))
}
pub fn semantics(&self, window_id: WindowId) -> Result<&[SemanticsNode]> {
let window = self.window(window_id)?;
Ok(&window.last_semantics)
}
pub fn window_title(&self, window_id: WindowId) -> Result<&str> {
let window = self.window(window_id)?;
Ok(&window.title)
}
pub fn window_icon(&self, window_id: WindowId) -> Result<Option<&WindowIcon>> {
let window = self.window(window_id)?;
Ok(window.icon.as_ref())
}
pub fn window_ids(&self) -> Vec<WindowId> {
self.windows.iter().map(|window| window.id).collect()
}
pub fn needs_render(&self, window_id: WindowId) -> Result<bool> {
let window = self.window(window_id)?;
Ok(window.needs_render())
}
pub fn schedule(&self, window_id: WindowId) -> Result<FrameSchedule> {
let window = self.window(window_id)?;
Ok(window.schedule)
}
pub fn focus_state(&self, window_id: WindowId) -> Result<FocusState> {
let window = self.window(window_id)?;
Ok(window.focus)
}
pub fn focused_widget(&self, window_id: WindowId) -> Result<Option<WidgetId>> {
Ok(self.focus_state(window_id)?.focused_widget)
}
pub fn pointer_capture_target(
&self,
window_id: WindowId,
pointer_id: u64,
) -> Result<Option<WidgetId>> {
let window = self.window(window_id)?;
Ok(window.pointer_capture.get(&pointer_id).copied())
}
pub fn window_initial_size(&self, window_id: WindowId) -> Result<Option<Size>> {
Ok(self.window(window_id)?.initial_size)
}
pub fn window_initial_position(&self, window_id: WindowId) -> Result<Option<Point>> {
Ok(self.window(window_id)?.initial_position)
}
pub fn window_cursor_state(&self, window_id: WindowId) -> Result<WindowCursorState> {
Ok(self.window(window_id)?.cursor.state)
}
pub fn widget_graph(&self, window_id: WindowId) -> Result<WidgetGraphSnapshot> {
let window = self.window(window_id)?;
Ok(window.graph.snapshot())
}
pub fn set_inspector_tracing(&mut self, window_id: WindowId, enabled: bool) -> Result<()> {
let window = self.window_mut(window_id)?;
if window.inspector_tracing_enabled != enabled {
window.clear_inspector_history();
window.last_render_diagnostics = RenderDiagnostics::default();
}
window.inspector_tracing_enabled = enabled;
Ok(())
}
pub fn inspector_tracing(&self, window_id: WindowId) -> Result<bool> {
Ok(self.window(window_id)?.inspector_tracing_enabled)
}
pub fn inspector_snapshot(&self, window_id: WindowId) -> Result<WindowInspectorSnapshot> {
let window = self.window(window_id)?;
Ok(window.inspector_snapshot())
}
pub fn overlay_snapshot(&self, window_id: WindowId) -> Result<OverlayManagerSnapshot> {
let window = self.window(window_id)?;
Ok(window.overlay_manager.snapshot())
}
pub fn take_overlay_traces(&mut self, window_id: WindowId) -> Result<Vec<OverlayTraceSample>> {
let window = self.window_mut(window_id)?;
Ok(window.overlay_manager.take_traces())
}
fn dispatch_controller_wake(&mut self) {
let sender = self.command_sender.clone();
let mut app_ctx = CommandCtx::new(sender.clone(), None);
let app_handlers = self.command_listeners.wake(&mut app_ctx);
self.apply_command_ctx(
app_ctx,
"scheduler wake",
"()",
None,
0,
CommandTarget::Application,
CommandDelivery::Broadcast,
app_handlers,
);
for index in 0..self.windows.len() {
let window_id = self.windows[index].id;
let mut ctx = CommandCtx::new(sender.clone(), Some(window_id));
let handlers = self.windows[index].command_listeners.wake(&mut ctx);
self.apply_command_ctx(
ctx,
"scheduler wake",
"()",
Some(index),
0,
CommandTarget::Window(window_id),
CommandDelivery::Broadcast,
handlers,
);
}
}
fn dispatch_queued_command(&mut self, queued: &QueuedCommand) {
match queued.target {
CommandTarget::Widget {
window_id,
widget_id,
} => {
if let Some(index) = self
.windows
.iter()
.position(|window| window.id == window_id)
{
let Some(dispatch) =
self.windows[index].dispatch_direct_command(widget_id, queued)
else {
self.windows[index].record_command_dispatch(command_sample(
queued,
Vec::new(),
false,
false,
));
return;
};
let (handlers, handled) = {
let handled = dispatch.handled;
(vec!["widget target".to_string()], handled)
};
let focus_request = dispatch.focus_request;
let mut effects = EventEffects::default();
effects.extend(dispatch);
let mut invalidations = Vec::new();
self.windows[index].apply_event_effects(effects, &mut invalidations);
if let Some(request) = focus_request {
let focus_effects = self.windows[index].apply_focus_request(request);
self.windows[index].apply_event_effects(focus_effects, &mut invalidations);
}
self.windows[index].record_command_invalidations(
&invalidations,
queued.key.name,
None,
);
self.windows[index].schedule.extend(&invalidations);
self.windows[index]
.pending_invalidations
.extend(invalidations);
self.windows[index]
.record_command_dispatch(command_sample(queued, handlers, handled, true));
}
}
CommandTarget::FocusedWidget(window_id) => {
if let Some(index) = self
.windows
.iter()
.position(|window| window.id == window_id)
{
let Some(target) = self.windows[index].focus.focused_widget else {
self.windows[index].record_command_dispatch(command_sample(
queued,
Vec::new(),
false,
false,
));
return;
};
let Some(dispatch) =
self.windows[index].dispatch_direct_command(target, queued)
else {
self.windows[index].record_command_dispatch(command_sample(
queued,
Vec::new(),
false,
false,
));
return;
};
let handled = { dispatch.handled };
let focus_request = dispatch.focus_request;
let mut effects = EventEffects::default();
effects.extend(dispatch);
let mut invalidations = Vec::new();
self.windows[index].apply_event_effects(effects, &mut invalidations);
if let Some(request) = focus_request {
let focus_effects = self.windows[index].apply_focus_request(request);
self.windows[index].apply_event_effects(focus_effects, &mut invalidations);
}
self.windows[index].record_command_invalidations(
&invalidations,
queued.key.name,
None,
);
self.windows[index].schedule.extend(&invalidations);
self.windows[index]
.pending_invalidations
.extend(invalidations);
self.windows[index].record_command_dispatch(command_sample(
queued,
vec!["focused widget".to_string()],
handled,
true,
));
}
}
CommandTarget::Window(window_id) => {
if let Some(index) = self
.windows
.iter()
.position(|window| window.id == window_id)
{
self.dispatch_to_window_listeners(index, queued);
}
}
CommandTarget::Application => {
let sender = self.command_sender.clone();
let mut ctx = CommandCtx::new(sender.clone(), None);
let broadcast = queued.delivery == CommandDelivery::Broadcast;
let command = Command::new(queued);
let handlers = self
.command_listeners
.dispatch(&mut ctx, &command, broadcast);
self.apply_command_ctx(
ctx,
queued.key.name,
queued.key.payload_type_name,
None,
queued.sequence,
queued.target,
queued.delivery,
handlers,
);
if broadcast {
for index in 0..self.windows.len() {
self.dispatch_to_window_listeners(index, queued);
}
}
}
}
}
fn dispatch_to_window_listeners(&mut self, index: usize, queued: &QueuedCommand) {
let sender = self.command_sender.clone();
let window_id = self.windows[index].id;
let mut ctx = CommandCtx::new(sender, Some(window_id));
let broadcast = queued.delivery == CommandDelivery::Broadcast;
let command = Command::new(queued);
let handlers = self.windows[index]
.command_listeners
.dispatch(&mut ctx, &command, broadcast);
self.apply_command_ctx(
ctx,
queued.key.name,
queued.key.payload_type_name,
Some(index),
queued.sequence,
queued.target,
queued.delivery,
handlers,
);
}
#[allow(clippy::too_many_arguments)]
fn apply_command_ctx(
&mut self,
mut ctx: CommandCtx,
source: &str,
payload_type: &str,
delivery_window: Option<usize>,
sequence: u64,
target: CommandTarget,
delivery: CommandDelivery,
handlers: Vec<String>,
) {
let handled = ctx.is_handled();
let invalidations = ctx.take_invalidations();
let every_window_invalidations = ctx.take_every_window_invalidations();
let animations = ctx.take_animation_targets();
for invalidation in invalidations {
self.apply_command_invalidation(invalidation, source, delivery_window);
}
for invalidation in every_window_invalidations {
for window_id in self.window_ids() {
let mut request = InvalidationRequest::new(
InvalidationTarget::Window(window_id),
invalidation.kind,
);
if let Some(region) = invalidation.region {
request = request.with_region(region);
}
self.apply_command_invalidation(
CommandInvalidation {
request,
reason: invalidation.reason.clone(),
},
source,
delivery_window,
);
}
}
for (window_id, widget_id) in animations {
if let Some(window) = self.windows.iter_mut().find(|window| match window_id {
Some(window_id) => window.id == window_id,
None => window.root.id() == widget_id || window.graph.contains(widget_id),
}) {
window.requested_animation_frames.insert(widget_id);
}
}
let sample = CommandDispatchSample {
sequence,
name: source.to_string(),
payload_type: payload_type.to_string(),
target,
delivery,
delivered: !handlers.is_empty(),
handlers,
handled,
};
if let Some(index) = delivery_window {
self.windows[index].record_command_dispatch(sample);
} else {
for window in &mut self.windows {
window.record_command_dispatch(sample.clone());
}
}
}
fn apply_command_invalidation(
&mut self,
invalidation: CommandInvalidation,
source: &str,
delivery_window: Option<usize>,
) {
let target_index = match invalidation.request.target {
InvalidationTarget::Window(window_id) => self
.windows
.iter()
.position(|window| window.id == window_id),
InvalidationTarget::Widget(widget_id) => self.windows.iter().position(|window| {
window.root.id() == widget_id || window.graph.contains(widget_id)
}),
InvalidationTarget::Surface(_) => delivery_window,
};
let Some(index) = target_index else {
return;
};
let request = invalidation.request;
push_trace(
&mut self.windows[index].pending_invalidation_diagnostics,
InvalidationTraceSample {
target: request.target,
kind: request.kind,
region: request.region,
source: format!("command:{source}"),
reason: invalidation.reason,
},
);
self.windows[index]
.schedule
.extend(std::slice::from_ref(&request));
self.windows[index].pending_invalidations.push(request);
}
fn alloc_window_id(&mut self) -> WindowId {
WindowId::new(NEXT_WINDOW_ID.fetch_add(1, Ordering::Relaxed))
}
fn window(&self, window_id: WindowId) -> Result<&WindowState> {
self.windows
.iter()
.find(|window| window.id == window_id)
.ok_or_else(|| Error::new(format!("window {} does not exist", window_id.get())))
}
fn window_mut(&mut self, window_id: WindowId) -> Result<&mut WindowState> {
self.windows
.iter_mut()
.find(|window| window.id == window_id)
.ok_or_else(|| Error::new(format!("window {} does not exist", window_id.get())))
}
}
impl Default for Runtime {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct FocusState {
pub focused_widget: Option<WidgetId>,
pub window_focused: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct WindowCursorState {
pub grab_mode: CursorGrabMode,
pub visible: bool,
pub revision: u64,
}
impl Default for WindowCursorState {
fn default() -> Self {
Self {
grab_mode: CursorGrabMode::None,
visible: true,
revision: 0,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub struct FrameSchedule {
pub measure: bool,
pub arrange: bool,
pub ordering: bool,
pub paint: bool,
pub semantics: bool,
pub hit_test: bool,
pub text: bool,
pub resources: bool,
}
impl FrameSchedule {
fn bootstrap() -> Self {
Self {
measure: true,
arrange: true,
ordering: false,
paint: true,
semantics: true,
hit_test: true,
text: false,
resources: false,
}
}
pub const fn any(self) -> bool {
self.measure
|| self.arrange
|| self.ordering
|| self.paint
|| self.semantics
|| self.hit_test
|| self.text
|| self.resources
}
pub const fn needs_render(self) -> bool {
self.measure
|| self.arrange
|| self.ordering
|| self.paint
|| self.semantics
|| self.text
|| self.resources
}
fn clear(&mut self) {
*self = Self::default();
}
fn mark(&mut self, kind: InvalidationKind) {
match kind {
InvalidationKind::Measure => {
self.measure = true;
self.arrange = true;
self.ordering = true;
self.paint = true;
self.hit_test = true;
self.semantics = true;
}
InvalidationKind::Arrange
| InvalidationKind::Transform
| InvalidationKind::Clip
| InvalidationKind::Visibility => {
self.ordering = true;
self.arrange = true;
self.paint = true;
self.hit_test = true;
self.semantics = true;
}
InvalidationKind::Ordering => {
self.ordering = true;
self.hit_test = true;
}
InvalidationKind::Effect => {
self.paint = true;
}
InvalidationKind::Paint => {
self.paint = true;
}
InvalidationKind::HitTest => {
self.hit_test = true;
}
InvalidationKind::Text => {
self.text = true;
self.measure = true;
self.arrange = true;
self.paint = true;
self.semantics = true;
}
InvalidationKind::Semantics => {
self.semantics = true;
}
InvalidationKind::Resources => {
self.resources = true;
self.paint = true;
}
}
}
fn extend(&mut self, invalidations: &[InvalidationRequest]) {
for request in invalidations {
self.mark(request.kind);
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct WidgetGeometrySnapshot {
pub layout_bounds: Rect,
pub input_bounds: Rect,
pub paint_bounds: Rect,
}
impl WidgetGeometrySnapshot {
pub const fn new(layout_bounds: Rect, input_bounds: Rect, paint_bounds: Rect) -> Self {
Self {
layout_bounds,
input_bounds,
paint_bounds,
}
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct WidgetNodeSnapshot {
pub id: WidgetId,
pub widget_name: &'static str,
pub parent: Option<WidgetId>,
pub children: Vec<WidgetId>,
pub measured_size: Size,
pub geometry: WidgetGeometrySnapshot,
pub local_bounds: Rect,
pub presentation_transform: Transform,
pub inverse_presentation_transform: Option<Transform>,
pub bounds: Rect,
pub paint_boundary: PaintBoundaryMode,
pub stack_host: WidgetId,
pub stack_surface: WidgetId,
pub stack_surface_order: usize,
pub transient_owner_surface: Option<WidgetId>,
pub overlay_owner: Option<WidgetId>,
pub is_overlay_owner: bool,
pub is_stack_host: bool,
pub is_stack_surface: bool,
pub hit_test: bool,
pub hit_test_self: bool,
pub stack_order_policy: StackOrderPolicy,
pub accepts_focus: bool,
pub focused: bool,
pub inert: bool,
}
#[derive(Debug, Clone, PartialEq)]
pub struct StackHostSnapshot {
pub host: WidgetId,
pub order_policy: StackOrderPolicy,
pub surfaces: Vec<WidgetId>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct WidgetGraphSnapshot {
pub root: WidgetId,
pub nodes: Vec<WidgetNodeSnapshot>,
pub stack_hosts: Vec<StackHostSnapshot>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum EventRoutePhase {
Capture,
Target,
Bubble,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EventRouteStep {
pub widget_id: WidgetId,
pub phase: EventRoutePhase,
pub handled: bool,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct EventRouteTraceSample {
pub sequence: u64,
pub event_kind: &'static str,
pub target: WidgetId,
pub path: Vec<WidgetId>,
pub steps: Vec<EventRouteStep>,
pub handled: bool,
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct TimerInspectorSnapshot {
pub token: TimerToken,
pub target: WidgetId,
pub deadline: f64,
pub delivering: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct AsyncTaskInspectorSnapshot {
pub token: AsyncWakeToken,
pub target: WidgetId,
pub pending_wake: bool,
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct SchedulerInspectorSnapshot {
pub timers: Vec<TimerInspectorSnapshot>,
pub async_tasks: Vec<AsyncTaskInspectorSnapshot>,
pub requested_animation_frames: Vec<WidgetId>,
pub delivering_animation_frames: Vec<WidgetId>,
pub last_animation_frame_time: Option<f64>,
}
#[derive(Debug, Clone, PartialEq, Default)]
pub struct InspectorHistorySnapshot {
pub event_routes: Vec<EventRouteTraceSample>,
pub reactive_invalidations: Vec<ReactiveInvalidationSample>,
pub command_dispatches: Vec<CommandDispatchSample>,
pub invalidations: Vec<InvalidationTraceSample>,
pub widget_rebuilds: Vec<WidgetRebuildSample>,
}
#[derive(Debug, Clone, PartialEq)]
pub struct WindowInspectorSnapshot {
pub window_id: WindowId,
pub title: String,
pub tracing_enabled: bool,
pub focus_state: FocusState,
pub schedule: FrameSchedule,
pub semantics: Vec<SemanticsNode>,
pub widget_graph: WidgetGraphSnapshot,
pub overlays: OverlayManagerSnapshot,
pub scheduler: SchedulerInspectorSnapshot,
pub widget_diagnostics: Vec<WidgetDiagnosticsSnapshot>,
pub last_render_diagnostics: RenderDiagnostics,
pub history: InspectorHistorySnapshot,
pub scene: Option<SceneStatistics>,
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct ScheduledTimer {
token: TimerToken,
deadline: f64,
target: WidgetId,
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct LayerTranslation {
widget_id: WidgetId,
delta: Vector,
}
#[derive(Debug, Clone, PartialEq)]
struct LayerDescriptorRefresh {
widget_id: WidgetId,
descriptor: SceneLayerDescriptor,
}
#[derive(Debug, Default)]
struct GraphChangeSet {
output_widgets: Vec<WidgetId>,
repaint_widgets: Vec<WidgetId>,
transform_widgets: Vec<LayerTranslation>,
}
const ANIMATION_FRAME_INTERVAL_SECONDS: f64 = 1.0 / 120.0;
#[derive(Debug, Clone)]
struct ActiveDrag {
session_id: DragSessionId,
scope_id: DragScopeId,
pointer_id: u64,
source: WidgetId,
start_position: Point,
position: Point,
payload: DragPayload,
allowed_effects: DropEffects,
preview_label: Option<Arc<str>>,
modifiers: Modifiers,
hover_path: Vec<WidgetId>,
accepted_target: Option<WidgetId>,
accepted_effect: DropEffect,
}
impl ActiveDrag {
fn from_request(request: BeginDragRequest) -> Self {
Self {
session_id: request.session_id,
scope_id: request.scope_id,
pointer_id: request.pointer_id,
source: request.source,
start_position: request.position,
position: request.position,
payload: request.payload,
allowed_effects: request.allowed_effects,
preview_label: request.preview_label.map(Arc::from),
modifiers: Modifiers::NONE,
hover_path: Vec::new(),
accepted_target: None,
accepted_effect: DropEffect::None,
}
}
fn event(
&self,
kind: DragEventKind,
position: Point,
target: Option<WidgetId>,
accepted_effect: DropEffect,
outcome: Option<DragOutcome>,
) -> Event {
Event::Drag(DragEvent {
kind,
session_id: self.session_id,
scope_id: self.scope_id,
pointer_id: self.pointer_id,
source: self.source,
target,
position,
start_position: self.start_position,
payload: self.payload.clone(),
allowed_effect: self.allowed_effects.default_effect(),
allowed_effects: self.allowed_effects,
accepted_effect,
preview_label: self.preview_label.clone(),
outcome,
modifiers: self.modifiers,
})
}
}
#[derive(Debug, Default)]
struct RuntimeCursorState {
state: WindowCursorState,
grab_owner: Option<WidgetId>,
visibility_owner: Option<WidgetId>,
}
struct WindowState {
id: WindowId,
title: String,
icon: Option<WindowIcon>,
initial_size: Option<Size>,
initial_position: Option<Point>,
root: WidgetPod,
measure_queries: measure_cache::SharedQueryCache,
output_cache: output_cache::SharedOutputCache,
graph: WidgetGraph,
overlay_manager: overlay::OverlayManager,
pending_overlay_focus: Option<FocusRequest>,
focus: FocusState,
focused_semantics: Option<WidgetId>,
schedule: FrameSchedule,
scale_factor: f32,
raw_dpi: Option<f32>,
safe_area: SafeAreaInsets,
viewport_hint: Option<Size>,
viewport: Option<Size>,
last_frame: Option<SceneFrame>,
last_paint_bounds_by_widget: HashMap<WidgetId, Rect>,
last_image_registry_base: Option<Arc<ImageRegistry>>,
retained_text_layout_count: usize,
last_semantics: Vec<SemanticsNode>,
pending_invalidations: Vec<InvalidationRequest>,
pending_local_output: HashMap<(WidgetId, InvalidationKind), usize>,
pending_reactive_diagnostics: Vec<ReactiveInvalidationSample>,
reactive_hub: Arc<reactive::ReactiveInvalidationHub>,
pointer_capture: HashMap<u64, WidgetId>,
cursor: RuntimeCursorState,
last_pointer_events: HashMap<u64, PointerEvent>,
pointer_hover_paths: HashMap<u64, Vec<WidgetId>>,
active_drag: Option<ActiveDrag>,
drag_targets_stale: bool,
scheduled_timers: Vec<ScheduledTimer>,
delivering_timers: HashMap<TimerToken, WidgetId>,
async_wake_targets: HashMap<AsyncWakeToken, WidgetId>,
pending_async_wakeups: VecDeque<AsyncWakeToken>,
requested_animation_frames: BTreeSet<WidgetId>,
delivering_animation_frames: VecDeque<WidgetId>,
active_motions: HashMap<(WidgetId, InvalidationKind), f64>,
motion_ends: HashMap<(WidgetId, InvalidationKind), Vec<f64>>,
frame_pacing: FramePacing,
last_animation_frame_time: Option<f64>,
next_animation_frame_index: u64,
pending_animation_wake_count: usize,
ime_composition_rect: Option<Rect>,
touches_down: HashSet<u64>,
held_ime_composition_rect: Option<Rect>,
last_tick_time: f64,
services: HostServices,
command_sender: CommandSender,
command_listeners: CommandListeners,
pending_command_diagnostics: Vec<CommandDispatchSample>,
pending_invalidation_diagnostics: Vec<InvalidationTraceSample>,
inspector_tracing_enabled: bool,
next_event_route_sequence: u64,
event_route_history: VecDeque<EventRouteTraceSample>,
reactive_invalidation_history: VecDeque<ReactiveInvalidationSample>,
command_dispatch_history: VecDeque<CommandDispatchSample>,
invalidation_history: VecDeque<InvalidationTraceSample>,
widget_rebuild_history: VecDeque<WidgetRebuildSample>,
last_render_diagnostics: RenderDiagnostics,
painted_render_options: Option<WindowRenderOptions>,
previous_graph: WidgetGraph,
previous_graph_saved: bool,
}
impl WindowState {
#[allow(clippy::too_many_arguments)]
fn new(
id: WindowId,
title: String,
icon: Option<WindowIcon>,
initial_size: Option<Size>,
initial_position: Option<Point>,
root: WidgetPod,
command_listeners: CommandListeners,
command_sender: CommandSender,
) -> Self {
let focus = FocusState {
focused_widget: None,
window_focused: true,
};
let reactive_hub = reactive::ReactiveInvalidationHub::new();
reactive::register_window(id, &reactive_hub);
Self {
id,
title,
icon,
initial_size,
initial_position,
graph: WidgetGraph::empty(root.id()),
measure_queries: measure_cache::MeasureQueryCache::shared(),
output_cache: output_cache::OutputCache::shared(),
overlay_manager: overlay::OverlayManager::default(),
pending_overlay_focus: None,
root,
focus,
focused_semantics: None,
schedule: FrameSchedule::bootstrap(),
scale_factor: 1.0,
raw_dpi: None,
safe_area: SafeAreaInsets::ZERO,
viewport_hint: None,
viewport: None,
last_frame: None,
last_paint_bounds_by_widget: HashMap::new(),
last_image_registry_base: None,
retained_text_layout_count: 0,
last_semantics: Vec::new(),
pending_invalidations: Vec::new(),
pending_local_output: HashMap::new(),
pending_reactive_diagnostics: Vec::new(),
reactive_hub,
pointer_capture: HashMap::new(),
cursor: RuntimeCursorState::default(),
last_pointer_events: HashMap::new(),
pointer_hover_paths: HashMap::new(),
active_drag: None,
drag_targets_stale: false,
scheduled_timers: Vec::new(),
delivering_timers: HashMap::new(),
async_wake_targets: HashMap::new(),
pending_async_wakeups: VecDeque::new(),
requested_animation_frames: BTreeSet::new(),
delivering_animation_frames: VecDeque::new(),
active_motions: HashMap::new(),
motion_ends: HashMap::new(),
frame_pacing: FramePacing::Timer,
last_animation_frame_time: None,
next_animation_frame_index: 0,
pending_animation_wake_count: 0,
ime_composition_rect: None,
touches_down: HashSet::new(),
held_ime_composition_rect: None,
last_tick_time: 0.0,
services: HostServices::default(),
command_sender,
command_listeners,
pending_command_diagnostics: Vec::new(),
pending_invalidation_diagnostics: Vec::new(),
inspector_tracing_enabled: false,
next_event_route_sequence: 0,
event_route_history: VecDeque::new(),
reactive_invalidation_history: VecDeque::new(),
command_dispatch_history: VecDeque::new(),
invalidation_history: VecDeque::new(),
widget_rebuild_history: VecDeque::new(),
last_render_diagnostics: RenderDiagnostics::default(),
painted_render_options: None,
previous_graph: WidgetGraph::default(),
previous_graph_saved: false,
}
}
fn repaint_for_render_options(&mut self) {
let options = window_render_options(self.id);
if options == self.painted_render_options {
return;
}
self.painted_render_options = options;
self.schedule.mark(InvalidationKind::Paint);
self.pending_invalidations.push(InvalidationRequest::new(
InvalidationTarget::Window(self.id),
InvalidationKind::Paint,
));
}
fn drain_reactive_invalidations(&mut self) {
const MAX_REACTIVE_ROUNDS: usize = 8;
for _ in 0..MAX_REACTIVE_ROUNDS {
let pending = self.reactive_hub.drain();
if pending.is_empty() {
break;
}
let mut invalidations = Vec::new();
let mut targets = BTreeSet::new();
for (request, mut sample, local_output) in pending {
let InvalidationTarget::Widget(widget_id) = request.target else {
continue;
};
let delivered = self.graph.is_empty() || self.graph.contains(widget_id);
sample.delivered = delivered;
if delivered {
push_trace(
&mut self.pending_invalidation_diagnostics,
InvalidationTraceSample {
target: request.target,
kind: request.kind,
region: request.region,
source: format!("reactive:{}", sample.source_name),
reason: Some(format!("observable version {}", sample.version)),
},
);
}
self.pending_reactive_diagnostics.push(sample);
if delivered {
if local_output {
*self
.pending_local_output
.entry((widget_id, request.kind))
.or_default() += 1;
}
targets.insert(widget_id);
invalidations.push(request);
}
}
for target in targets {
let command = command::queued_command(
CommandTarget::Widget {
window_id: self.id,
widget_id: target,
},
CommandDelivery::Directed,
REACTIVE_CHANGED,
(),
);
let Some(dispatch) = self.dispatch_direct_command(target, &command) else {
continue;
};
if dispatch.handled {
self.pending_local_output.retain(|(id, _), _| *id != target);
}
let focus_request = dispatch.focus_request;
let mut effects = EventEffects::default();
effects.extend(dispatch);
self.apply_event_effects(effects, &mut invalidations);
if let Some(request) = focus_request {
let focus_effects = self.apply_focus_request(request);
self.apply_event_effects(focus_effects, &mut invalidations);
}
}
self.schedule.extend(&invalidations);
self.pending_invalidations.extend(invalidations);
}
}
fn needs_render(&self) -> bool {
self.last_frame.is_none()
|| self.schedule.needs_render()
|| self.reactive_hub.has_pending()
|| window_render_options(self.id) != self.painted_render_options
}
fn handle_event(
&mut self,
event: Event,
text_system: Arc<TextSystem>,
font_registry: Arc<FontRegistry>,
image_registry: Arc<ImageRegistry>,
) -> bool {
if matches!(event, Event::Window(WindowEvent::RedrawRequested)) {
diagnostics::begin_widget_timing_collection();
sui_text::begin_text_timing_collection();
}
if matches!(event, Event::Wake(WakeEvent::AnimationFrame { .. })) {
self.pending_animation_wake_count = self.pending_animation_wake_count.saturating_add(1);
}
if let Event::Pointer(pointer) = &event {
if pointer.pointer_kind == PointerKind::Touch && pointer.kind == PointerEventKind::Down
{
if self.touches_down.is_empty() {
self.held_ime_composition_rect = self.ime_composition_rect;
}
self.touches_down.insert(pointer.pointer_id);
}
self.last_pointer_events
.insert(pointer.pointer_id, pointer.clone());
}
self.preprocess_window_event(&event);
self.ensure_graph_for_event(&event, text_system, font_registry, image_registry);
let mut invalidations = Vec::new();
self.apply_pending_overlay_focus(&mut invalidations);
let captured_target = match &event {
Event::Pointer(pointer) => self.pointer_capture.get(&pointer.pointer_id).copied(),
_ => None,
};
let pointer_hit_target = match &event {
Event::Pointer(pointer) => self.pointer_hit_target(pointer.position),
_ => None,
};
let mut hit_target = match &event {
Event::Pointer(_) if captured_target.is_some() => None,
Event::Pointer(_) => pointer_hit_target,
_ => None,
};
if matches!(event, Event::Window(WindowEvent::Focused(false))) {
self.cancel_all_pointer_captures(&mut invalidations);
self.pointer_capture.clear();
self.last_pointer_events.clear();
self.touches_down.clear();
self.release_ime_hold();
let position = self.active_drag.as_ref().map(|drag| drag.position);
if let Some(position) = position {
let effects = self.finish_active_drag(position, true);
self.apply_event_effects(effects, &mut invalidations);
}
self.reset_cursor_state();
}
if self.drag_targets_stale {
self.drag_targets_stale = false;
if !matches!(
&event,
Event::Pointer(pointer)
if self.is_drag_pointer(pointer)
&& matches!(pointer.kind, PointerEventKind::Move | PointerEventKind::Up)
) {
let effects = self.refresh_active_drag();
self.apply_event_effects(effects, &mut invalidations);
}
}
if let Event::Keyboard(key) = &event
&& self.active_drag.is_some()
&& self.handle_drag_key_event(key, &mut invalidations)
{
self.finish_event(&event);
self.record_event_invalidations(&invalidations, &event);
self.schedule.extend(&invalidations);
self.pending_invalidations.extend(invalidations);
return true;
}
let mut skip_primary_route = false;
if let Event::Pointer(pointer) = &event {
let hover_route = self.update_pointer_hover_path(pointer, hit_target);
self.apply_event_effects(hover_route.effects, &mut invalidations);
if let Some(request) = hover_route.focus_request {
let focus_effects = self.apply_focus_request(request);
self.apply_event_effects(focus_effects, &mut invalidations);
}
skip_primary_route = hover_route.skip_primary_route;
}
if skip_primary_route {
self.finish_event(&event);
self.record_event_invalidations(&invalidations, &event);
self.schedule.extend(&invalidations);
self.pending_invalidations.extend(invalidations);
return false;
}
if matches!(
&event,
Event::Keyboard(key)
if key.state == KeyState::Pressed
&& key.key == "BrowserBack"
&& !key.repeat
&& !key.is_composing
) && self.ime_composition_rect.is_some()
&& self.focus.focused_widget.is_some()
{
self.ime_composition_rect = None;
self.held_ime_composition_rect = None;
let effects = self.apply_focus_request_unconstrained(FocusRequest::Clear);
self.apply_event_effects(effects, &mut invalidations);
self.finish_event(&event);
self.record_event_invalidations(&invalidations, &event);
self.schedule.extend(&invalidations);
self.pending_invalidations.extend(invalidations);
return true;
}
if matches!(
&event,
Event::Keyboard(key)
if key.state == KeyState::Pressed
&& matches!(key.key.as_str(), "Escape" | "BrowserBack")
&& !key.repeat
&& !key.is_composing
) && self.dispatch_overlay_dismissal(
OverlayDismissReason::Escape,
None,
&mut invalidations,
) {
self.finish_event(&event);
self.record_event_invalidations(&invalidations, &event);
self.schedule.extend(&invalidations);
self.pending_invalidations.extend(invalidations);
return true;
}
if let Event::Pointer(pointer) = &event
&& pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary)
&& let Some(entry) = self
.overlay_manager
.topmost_dismissible(OverlayDismissReason::OutsidePointer)
.cloned()
&& !hit_target.is_some_and(|target| self.target_is_in_overlay(entry.owner, target))
{
self.dispatch_overlay_dismissal(
OverlayDismissReason::OutsidePointer,
Some(pointer.position),
&mut invalidations,
);
}
if let Some(modal) = self.overlay_manager.active_modal()
&& hit_target.is_some_and(|target| !self.target_is_in_overlay(modal, target))
{
hit_target = Some(modal);
}
let target = self.resolve_event_target(&event, hit_target);
let route = self.route_event(target, &event);
let handled = route.handled;
let focus_request = route
.focus_request
.or_else(|| self.default_focus_request(&event, hit_target, &route.path));
self.apply_event_effects(route.effects, &mut invalidations);
if let Some(request) = focus_request {
let focus_effects = self.apply_focus_request(request);
self.apply_event_effects(focus_effects, &mut invalidations);
}
if let Event::Pointer(pointer) = &event {
let drag_effects = self.handle_drag_pointer_event(pointer, pointer_hit_target);
self.apply_event_effects(drag_effects, &mut invalidations);
}
self.finish_event(&event);
self.record_event_invalidations(&invalidations, &event);
self.schedule.extend(&invalidations);
self.pending_invalidations.extend(invalidations);
handled
}
fn record_command_dispatch(&mut self, sample: CommandDispatchSample) {
command_history::record_window_command_dispatch(self.id, sample.clone());
push_trace(&mut self.pending_command_diagnostics, sample);
}
fn record_event_invalidations(&mut self, invalidations: &[InvalidationRequest], event: &Event) {
let source = event_trace_source(event);
extend_traces(
&mut self.pending_invalidation_diagnostics,
invalidations.iter().map(|request| InvalidationTraceSample {
target: request.target,
kind: request.kind,
region: request.region,
source: source.clone(),
reason: None,
}),
);
}
fn target_is_in_overlay(&self, owner: WidgetId, target: WidgetId) -> bool {
target == owner || self.graph.is_ancestor_of(owner, target)
}
fn dispatch_overlay_dismissal(
&mut self,
reason: OverlayDismissReason,
pointer_position: Option<Point>,
invalidations: &mut Vec<InvalidationRequest>,
) -> bool {
let Some(entry) = self.overlay_manager.topmost_dismissible(reason).cloned() else {
return false;
};
let mut request = OverlayDismissRequest::new(reason);
request.pointer_position = pointer_position;
let queued = command::queued_command(
CommandTarget::Widget {
window_id: self.id,
widget_id: entry.owner,
},
CommandDelivery::Directed,
OVERLAY_DISMISS_REQUEST,
request,
);
let Some(dispatch) = self.dispatch_direct_command(entry.owner, &queued) else {
return false;
};
let handled = dispatch.handled;
let focus_request = dispatch.focus_request;
let mut effects = EventEffects::default();
effects.extend(dispatch);
self.apply_event_effects(effects, invalidations);
if let Some(request) = focus_request {
let effects = self.apply_focus_request(request);
self.apply_event_effects(effects, invalidations);
}
if handled {
self.overlay_manager
.trace_dismissal(entry.owner, entry.options.kind, reason);
}
handled
}
fn handle_semantics_action(
&mut self,
target: WidgetId,
action: SemanticsActionRequest,
text_system: Arc<TextSystem>,
font_registry: Arc<FontRegistry>,
image_registry: Arc<ImageRegistry>,
) -> bool {
let Some(node) = self
.last_semantics
.iter()
.find(|node| node.id == target)
.cloned()
else {
return false;
};
if node.state.hidden
|| node.state.disabled
|| !node.actions.contains(&action.advertised_action())
{
return false;
}
if matches!(
(&action, node.state.expanded),
(SemanticsActionRequest::Expand, Some(true))
| (SemanticsActionRequest::Collapse, Some(false))
) {
return true;
}
let event = Event::Semantics(SemanticsEvent::new(target, action.clone()));
self.ensure_graph_for_event(
&event,
Arc::clone(&text_system),
Arc::clone(&font_registry),
Arc::clone(&image_registry),
);
let route_target = self.semantics_route_target(target);
let route = self.route_event(route_target, &event);
let handled = route.handled;
let semantics_was_focused = self.focused_semantics == Some(target);
let mut focus_request = route.focus_request;
let widget_requested_focus = matches!(focus_request, Some(FocusRequest::Focus(_)));
let mut focus_succeeded = false;
let mut invalidations = Vec::new();
self.apply_event_effects(route.effects, &mut invalidations);
match action {
SemanticsActionRequest::Focus => {
let runtime_focus_request = focus_request
.is_none()
.then(|| self.focus_request_for(route_target))
.flatten();
focus_succeeded =
handled || widget_requested_focus || runtime_focus_request.is_some();
focus_request = focus_request.or(runtime_focus_request);
}
SemanticsActionRequest::Blur if semantics_was_focused => {
focus_request = Some(FocusRequest::Clear);
}
_ => {}
}
if let Some(request) = focus_request {
let focus_effects = self.apply_focus_request(request);
self.apply_event_effects(focus_effects, &mut invalidations);
}
match action {
SemanticsActionRequest::Focus if focus_succeeded => {
self.focused_semantics = Some(target);
self.schedule.mark(InvalidationKind::Semantics);
}
SemanticsActionRequest::Blur if semantics_was_focused => {
self.focused_semantics = None;
self.schedule.mark(InvalidationKind::Semantics);
}
_ => {}
}
self.schedule.extend(&invalidations);
self.pending_invalidations.extend(invalidations);
let pointer_fallback = matches!(
action,
SemanticsActionRequest::Activate
| SemanticsActionRequest::Expand
| SemanticsActionRequest::Collapse
);
if pointer_fallback && !handled && !node.bounds.is_empty() {
self.dispatch_semantics_pointer_activation(
node.bounds,
text_system,
font_registry,
image_registry,
);
return true;
}
handled
|| matches!(action, SemanticsActionRequest::Focus) && focus_succeeded
|| matches!(action, SemanticsActionRequest::Blur) && semantics_was_focused
}
fn semantics_route_target(&self, target: WidgetId) -> WidgetId {
let mut current = Some(target);
let mut visited = HashSet::new();
while let Some(candidate) = current {
if !visited.insert(candidate) {
break;
}
if self.graph.contains(candidate) {
return candidate;
}
current = self
.last_semantics
.iter()
.find(|node| node.id == candidate)
.and_then(|node| node.parent);
}
self.root.id()
}
fn focus_request_for(&self, target: WidgetId) -> Option<FocusRequest> {
self.graph.path_to(target).and_then(|path| {
path.into_iter()
.rev()
.find(|widget_id| {
self.graph
.node(*widget_id)
.is_some_and(|node| node.accepts_focus)
})
.map(FocusRequest::Focus)
})
}
fn dispatch_semantics_pointer_activation(
&mut self,
bounds: Rect,
text_system: Arc<TextSystem>,
font_registry: Arc<FontRegistry>,
image_registry: Arc<ImageRegistry>,
) {
let position = Point::new(
bounds.x() + bounds.width() * 0.5,
bounds.y() + bounds.height() * 0.5,
);
let mut down = PointerEvent::new(PointerEventKind::Down, position);
down.button = Some(PointerButton::Primary);
down.buttons.insert(PointerButton::Primary);
self.handle_event(
Event::Pointer(down),
Arc::clone(&text_system),
Arc::clone(&font_registry),
Arc::clone(&image_registry),
);
let mut up = PointerEvent::new(PointerEventKind::Up, position);
up.button = Some(PointerButton::Primary);
self.handle_event(
Event::Pointer(up),
text_system,
font_registry,
image_registry,
);
}
fn update_pointer_hover_path(
&mut self,
pointer: &PointerEvent,
hit_target: Option<WidgetId>,
) -> HoverTransitionResult {
let skip_primary_route = matches!(
pointer.kind,
PointerEventKind::Enter | PointerEventKind::Leave
);
let next_path = match pointer.kind {
PointerEventKind::Move | PointerEventKind::Enter
if pointer.buttons.is_empty()
&& !self.pointer_capture.contains_key(&pointer.pointer_id) =>
{
self.hover_transition_path(hit_target)
}
PointerEventKind::Leave | PointerEventKind::Cancel => Vec::new(),
_ => {
return HoverTransitionResult {
skip_primary_route,
..HoverTransitionResult::default()
};
}
};
let previous_path = self
.pointer_hover_paths
.remove(&pointer.pointer_id)
.unwrap_or_default();
if previous_path == next_path {
if !next_path.is_empty() {
self.pointer_hover_paths
.insert(pointer.pointer_id, next_path);
}
return HoverTransitionResult {
skip_primary_route,
..HoverTransitionResult::default()
};
}
let shared_prefix_len = previous_path
.iter()
.zip(next_path.iter())
.take_while(|(left, right)| left == right)
.count();
let mut result = HoverTransitionResult {
skip_primary_route,
..HoverTransitionResult::default()
};
let mut leave_pointer = pointer.clone();
leave_pointer.kind = PointerEventKind::Leave;
let leave_event = Event::Pointer(leave_pointer);
for widget_id in previous_path[shared_prefix_len..].iter().rev().copied() {
let dispatch = self.dispatch_direct_event(widget_id, &leave_event);
let dispatch_focus_request = dispatch.focus_request;
result.effects.extend(dispatch);
if dispatch_focus_request.is_some() {
result.focus_request = dispatch_focus_request;
}
}
let mut enter_pointer = pointer.clone();
enter_pointer.kind = PointerEventKind::Enter;
let enter_event = Event::Pointer(enter_pointer);
for widget_id in next_path[shared_prefix_len..].iter().copied() {
let dispatch = self.dispatch_direct_event(widget_id, &enter_event);
let dispatch_focus_request = dispatch.focus_request;
result.effects.extend(dispatch);
if dispatch_focus_request.is_some() {
result.focus_request = dispatch_focus_request;
}
}
if !next_path.is_empty() {
self.pointer_hover_paths
.insert(pointer.pointer_id, next_path);
}
result
}
fn hover_transition_path(&self, hit_target: Option<WidgetId>) -> Vec<WidgetId> {
hit_target
.and_then(|target| self.graph.path_to(target))
.map(|path| path.into_iter().skip(1).collect())
.unwrap_or_default()
}
fn dispatch_direct_event(&mut self, target: WidgetId, event: &Event) -> widget::EventDispatch {
let path = self.graph.path_to(target);
let dpi_info = self.current_dpi_info();
self.root
.dispatch_event_for_path(
path.as_deref().unwrap_or(&[self.root.id()]),
self.id,
dpi_info,
self.last_tick_time,
EventPhase::Target,
self.focus.focused_widget,
&self.services,
&self.command_sender,
event,
)
.or_else(|| {
self.root.dispatch_event_for(
target,
self.id,
dpi_info,
self.last_tick_time,
EventPhase::Target,
self.focus.focused_widget,
&self.services,
&self.command_sender,
event,
)
})
.unwrap_or_else(empty_dispatch)
}
fn dispatch_direct_command(
&mut self,
target: WidgetId,
command: &QueuedCommand,
) -> Option<widget::EventDispatch> {
let path = if target == self.root.id() {
vec![target]
} else {
self.graph.path_to(target)?
};
let dpi_info = self.current_dpi_info();
let command = Command::new(command);
self.root
.dispatch_command_for_path(
&path,
self.id,
dpi_info,
self.last_tick_time,
self.focus.focused_widget,
&self.services,
&self.command_sender,
&command,
)
.or_else(|| {
self.root.dispatch_command_for(
target,
self.id,
dpi_info,
self.last_tick_time,
self.focus.focused_widget,
&self.services,
&self.command_sender,
&command,
)
})
}
fn record_command_invalidations(
&mut self,
invalidations: &[InvalidationRequest],
source: &str,
reason: Option<&str>,
) {
extend_traces(
&mut self.pending_invalidation_diagnostics,
invalidations.iter().map(|request| InvalidationTraceSample {
target: request.target,
kind: request.kind,
region: request.region,
source: format!("command:{source}"),
reason: reason.map(str::to_string),
}),
);
}
fn pointer_hit_target(&mut self, point: Point) -> Option<WidgetId> {
let floating_hit = self.floating_layer_hit_test(point);
let focused_floating_hit = if floating_hit.is_none() {
self.focused_floating_layer_hit_test(point)
} else {
None
};
floating_hit
.or(focused_floating_hit)
.or_else(|| self.graph.hit_test(point))
}
fn floating_layer_hit_test(&mut self, point: Point) -> Option<WidgetId> {
let effect_hit = {
let scene = self.last_frame.as_ref().map(|frame| &frame.scene)?;
scene_hit_test_for_phase(
scene,
point,
HitTestCompositionPhase::Effect,
HitTestCompositionPhase::Normal,
)
};
if let Some(widget_id) = effect_hit
&& self
.current_widget_matches_hit_test_phase(widget_id, HitTestCompositionPhase::Effect)
{
return self
.graph
.hit_test_within(widget_id, point)
.or(Some(widget_id));
}
let overlay_hit = {
let scene = self.last_frame.as_ref().map(|frame| &frame.scene)?;
scene_hit_test_for_phase(
scene,
point,
HitTestCompositionPhase::Overlay,
HitTestCompositionPhase::Normal,
)
};
overlay_hit.and_then(|widget_id| {
self.current_widget_matches_hit_test_phase(widget_id, HitTestCompositionPhase::Overlay)
.then(|| {
self.graph
.hit_test_within(widget_id, point)
.unwrap_or(widget_id)
})
})
}
fn focused_floating_layer_hit_test(&mut self, point: Point) -> Option<WidgetId> {
let focused = self.focus.focused_widget?;
if !self.current_widget_matches_hit_test_phase(focused, HitTestCompositionPhase::Overlay)
&& !self.current_widget_matches_hit_test_phase(focused, HitTestCompositionPhase::Effect)
{
return None;
}
let scene = self.last_frame.as_ref().map(|frame| &frame.scene)?;
let descriptor = collect_scene_layers(scene).get(&focused)?.clone();
(descriptor.hit_test && descriptor.paint_bounds.contains(point)).then_some(focused)
}
fn current_widget_matches_hit_test_phase(
&mut self,
widget_id: WidgetId,
target_phase: HitTestCompositionPhase,
) -> bool {
if !self.graph.node(widget_id).is_some_and(|node| node.hit_test) {
return false;
}
let Some(composition_mode) = self.current_widget_composition_mode(widget_id) else {
return false;
};
next_hit_test_phase(HitTestCompositionPhase::Normal, composition_mode) == target_phase
}
fn current_widget_composition_mode(
&mut self,
widget_id: WidgetId,
) -> Option<LayerCompositionMode> {
self.root.layer_composition_mode_for(widget_id)
}
fn wants_animation_frame(&self) -> bool {
!self.requested_animation_frames.is_empty()
|| !self.active_motions.is_empty()
|| !self.motion_ends.is_empty()
}
fn animation_frame_deadline(&self) -> Option<f64> {
(self.frame_pacing == FramePacing::Timer && self.wants_animation_frame()).then_some(
self.last_animation_frame_time
.map_or(self.last_tick_time, |last| {
last + ANIMATION_FRAME_INTERVAL_SECONDS
}),
)
}
fn frame_time(&self) -> f64 {
self.last_animation_frame_time
.map_or(self.last_tick_time, |frame| frame.max(self.last_tick_time))
}
fn start_animation_frame(&mut self, frame_time: f64) -> Vec<Event> {
let frame_time = self
.last_animation_frame_time
.map_or(frame_time, |last| frame_time.max(last));
let delta = self
.last_animation_frame_time
.map(|last| frame_time - last)
.unwrap_or(0.0);
let frame_index = self.next_animation_frame_index;
self.next_animation_frame_index = self.next_animation_frame_index.saturating_add(1);
let requested = std::mem::take(&mut self.requested_animation_frames);
self.delivering_animation_frames
.extend(requested.iter().copied());
let events = requested
.iter()
.map(|_| {
Event::Wake(WakeEvent::AnimationFrame {
time: frame_time,
delta,
frame_index,
})
})
.collect();
self.last_animation_frame_time = Some(frame_time);
self.tick_motions(frame_time);
if self.delivering_animation_frames.is_empty() && !self.wants_animation_frame() {
self.last_animation_frame_time = None;
}
events
}
fn tick_motions(&mut self, frame_time: f64) {
if self.active_motions.is_empty() && self.motion_ends.is_empty() {
return;
}
let mut invalidations = Vec::with_capacity(self.active_motions.len());
let graph = &self.graph;
self.active_motions.retain(|&(widget_id, kind), until| {
if graph.contains(widget_id) {
invalidations.push(InvalidationRequest::new(
InvalidationTarget::Widget(widget_id),
kind,
));
}
frame_time < *until
});
self.motion_ends.retain(|&(widget_id, kind), ends| {
if !graph.contains(widget_id) {
return true;
}
let pending = ends.len();
ends.retain(|end| frame_time < *end);
if ends.len() != pending {
invalidations.push(InvalidationRequest::new(
InvalidationTarget::Widget(widget_id),
kind,
));
}
!ends.is_empty()
});
for request in &invalidations {
if let InvalidationTarget::Widget(widget_id) = request.target {
*self
.pending_local_output
.entry((widget_id, request.kind))
.or_default() += 1;
}
}
self.schedule.extend(&invalidations);
self.pending_invalidations.extend(invalidations);
}
fn begin_animation_frame(&mut self, frame_time: f64) -> Vec<Event> {
if !self.wants_animation_frame() {
return Vec::new();
}
self.start_animation_frame(frame_time)
}
fn next_wakeup_time(&self) -> Option<f64> {
let mut next = self
.scheduled_timers
.iter()
.map(|timer| timer.deadline)
.min_by(|left, right| left.total_cmp(right));
if !self.pending_async_wakeups.is_empty() {
next = Some(next.map_or(self.last_tick_time, |deadline| {
deadline.min(self.last_tick_time)
}));
}
if let Some(animation_deadline) = self.animation_frame_deadline() {
next = Some(next.map_or(animation_deadline, |deadline| {
deadline.min(animation_deadline)
}));
}
next
}
fn active_animated_widget_count(&self) -> usize {
self.requested_animation_frames
.iter()
.copied()
.chain(self.delivering_animation_frames.iter().copied())
.chain(self.active_motions.keys().map(|(widget_id, _)| *widget_id))
.chain(self.motion_ends.keys().map(|(widget_id, _)| *widget_id))
.collect::<BTreeSet<_>>()
.len()
}
fn animation_frame_is_transform_only(
&self,
repainted: bool,
layer_updates: &[SceneLayerUpdate],
) -> bool {
!repainted
&& !layer_updates.is_empty()
&& layer_updates.iter().all(|update| {
matches!(
update.kind,
SceneLayerUpdateKind::Transform
| SceneLayerUpdateKind::Effect
| SceneLayerUpdateKind::Visibility
)
})
}
fn drain_ready_events(&mut self) -> Vec<Event> {
let now = self.last_tick_time;
let mut ready = Vec::new();
let mut pending_timers = Vec::with_capacity(self.scheduled_timers.len());
for timer in self.scheduled_timers.drain(..) {
if timer.deadline <= now {
self.delivering_timers.insert(timer.token, timer.target);
ready.push(Event::Wake(WakeEvent::Timer {
token: timer.token,
time: now,
deadline: timer.deadline,
}));
} else {
pending_timers.push(timer);
}
}
self.scheduled_timers = pending_timers;
while let Some(token) = self.pending_async_wakeups.pop_front() {
if self.async_wake_targets.contains_key(&token) {
ready.push(Event::Wake(WakeEvent::Async { token, time: now }));
}
}
if self
.animation_frame_deadline()
.is_some_and(|deadline| deadline <= now)
{
ready.extend(self.start_animation_frame(now));
} else if self.delivering_animation_frames.is_empty() && !self.wants_animation_frame() {
self.last_animation_frame_time = None;
}
ready
}
fn wake_async(&mut self, token: AsyncWakeToken) -> bool {
if !self.async_wake_targets.contains_key(&token) {
return false;
}
self.pending_async_wakeups.push_back(token);
true
}
fn invalidate_layout_for_viewport_change(&mut self) {
self.schedule.mark(InvalidationKind::Measure);
self.pending_invalidations.push(InvalidationRequest::new(
InvalidationTarget::Window(self.id),
InvalidationKind::Measure,
));
}
fn preprocess_window_event(&mut self, event: &Event) {
let Event::Window(window_event) = event else {
return;
};
match window_event {
WindowEvent::Resized(size) => {
self.viewport_hint = Some(*size);
self.invalidate_layout_for_viewport_change();
}
WindowEvent::ScaleFactorChanged {
scale_factor,
raw_dpi,
suggested_size,
} => {
self.scale_factor = *scale_factor as f32;
self.raw_dpi = *raw_dpi;
if let Some(size) = suggested_size {
self.viewport_hint = Some(*size);
}
self.invalidate_layout_for_viewport_change();
}
WindowEvent::SafeAreaChanged(safe_area) => {
let safe_area = safe_area.normalized();
if self.safe_area != safe_area {
self.safe_area = safe_area;
self.invalidate_layout_for_viewport_change();
}
}
WindowEvent::Focused(focused) => {
self.focus.window_focused = *focused;
}
WindowEvent::RedrawRequested => {
self.schedule.mark(InvalidationKind::Paint);
}
WindowEvent::CloseRequested
| WindowEvent::Moved(_)
| WindowEvent::Occluded(_)
| WindowEvent::ExternalFileHovered(_)
| WindowEvent::ExternalFileHoverCancelled
| WindowEvent::ExternalFileDropped(_) => {}
}
}
fn ensure_graph_for_event(
&mut self,
event: &Event,
text_system: Arc<TextSystem>,
font_registry: Arc<FontRegistry>,
image_registry: Arc<ImageRegistry>,
) {
if self.schedule.measure || self.schedule.arrange || self.viewport.is_none() {
let scope_source = self.pending_invalidations.clone();
let invalidations = self.run_measure_arrange_pass(
&scope_source,
text_system,
font_registry,
image_registry,
);
self.schedule.extend(&invalidations);
self.pending_invalidations.extend(invalidations);
return;
}
if self.schedule.hit_test || self.graph.is_empty() {
self.refresh_graph();
}
if matches!(event, Event::Keyboard(_) | Event::Ime(_))
&& self.focus.focused_widget.is_some()
&& !self
.graph
.contains(self.focus.focused_widget.unwrap_or_default())
{
self.focus.focused_widget = None;
self.focused_semantics = None;
}
}
fn resolve_event_target(&self, event: &Event, hit_target: Option<WidgetId>) -> WidgetId {
match event {
Event::Pointer(pointer) => self
.pointer_capture
.get(&pointer.pointer_id)
.copied()
.or(hit_target)
.unwrap_or(self.root.id()),
Event::RawMouseMotion(_) => self
.cursor
.grab_owner
.filter(|_| self.cursor.state.grab_mode != CursorGrabMode::None)
.unwrap_or(self.root.id()),
Event::Keyboard(_) | Event::Ime(_) => {
self.focus.focused_widget.unwrap_or(self.root.id())
}
Event::Semantics(semantics) => self.semantics_route_target(semantics.target),
Event::Wake(wake_event) => self.wake_target(*wake_event).unwrap_or(self.root.id()),
_ => self.root.id(),
}
}
fn wake_target(&self, wake_event: WakeEvent) -> Option<WidgetId> {
match wake_event {
WakeEvent::Timer { token, .. } => self.delivering_timers.get(&token).copied(),
WakeEvent::Async { token, .. } => self.async_wake_targets.get(&token).copied(),
WakeEvent::AnimationFrame { .. } => self.delivering_animation_frames.front().copied(),
}
}
fn apply_event_effects(
&mut self,
effects: EventEffects,
invalidations: &mut Vec<InvalidationRequest>,
) {
invalidations.extend(effects.invalidations);
self.apply_wake_requests(effects.wake_requests);
self.apply_pointer_capture_requests(effects.pointer_capture_requests, invalidations);
self.apply_cursor_requests(effects.cursor_requests);
self.apply_drag_requests(effects.drag_requests, invalidations);
self.apply_posted_events(effects.posted_events, invalidations);
self.apply_posted_commands(effects.posted_commands, invalidations);
}
fn apply_posted_events(
&mut self,
mut posted: Vec<widget::PostedEventRequest>,
invalidations: &mut Vec<InvalidationRequest>,
) {
const MAX_POSTED_EVENT_ROUNDS: usize = 8;
let mut rounds = 0;
while !posted.is_empty() && rounds < MAX_POSTED_EVENT_ROUNDS {
rounds += 1;
for request in std::mem::take(&mut posted) {
let dispatch = self.dispatch_direct_event(request.target, &request.event);
invalidations.extend(dispatch.invalidations);
self.apply_wake_requests(dispatch.wake_requests);
self.apply_pointer_capture_requests(
dispatch.pointer_capture_requests,
invalidations,
);
self.apply_cursor_requests(dispatch.cursor_requests);
self.apply_drag_requests(dispatch.drag_requests, invalidations);
posted.extend(dispatch.posted_events);
self.apply_posted_commands(dispatch.posted_commands, invalidations);
if let Some(request) = dispatch.focus_request {
let focus_effects = self.apply_focus_request(request);
invalidations.extend(focus_effects.invalidations);
self.apply_wake_requests(focus_effects.wake_requests);
self.apply_pointer_capture_requests(
focus_effects.pointer_capture_requests,
invalidations,
);
self.apply_cursor_requests(focus_effects.cursor_requests);
self.apply_drag_requests(focus_effects.drag_requests, invalidations);
posted.extend(focus_effects.posted_events);
self.apply_posted_commands(focus_effects.posted_commands, invalidations);
}
}
}
}
fn apply_posted_commands(
&mut self,
mut posted: Vec<widget::PostedCommandRequest>,
invalidations: &mut Vec<InvalidationRequest>,
) {
const MAX_POSTED_COMMAND_ROUNDS: usize = 8;
let mut rounds = 0;
while !posted.is_empty() && rounds < MAX_POSTED_COMMAND_ROUNDS {
rounds += 1;
for request in std::mem::take(&mut posted) {
let CommandTarget::Widget { widget_id, .. } = request.command.target else {
continue;
};
let Some(dispatch) = self.dispatch_direct_command(widget_id, &request.command)
else {
self.record_command_dispatch(command_sample(
&request.command,
Vec::new(),
false,
false,
));
continue;
};
self.record_command_invalidations(
&dispatch.invalidations,
request.command.key.name,
Some("posted by widget"),
);
invalidations.extend(dispatch.invalidations);
self.apply_wake_requests(dispatch.wake_requests);
self.apply_pointer_capture_requests(
dispatch.pointer_capture_requests,
invalidations,
);
self.apply_cursor_requests(dispatch.cursor_requests);
self.apply_drag_requests(dispatch.drag_requests, invalidations);
self.apply_posted_events(dispatch.posted_events, invalidations);
posted.extend(dispatch.posted_commands);
self.record_command_dispatch(command_sample(
&request.command,
vec!["widget target".to_string()],
dispatch.handled,
true,
));
if let Some(focus_request) = dispatch.focus_request {
let effects = self.apply_focus_request(focus_request);
self.apply_event_effects(effects, invalidations);
}
}
}
}
fn apply_drag_requests(
&mut self,
requests: Vec<DragRequest>,
invalidations: &mut Vec<InvalidationRequest>,
) {
for request in requests {
match request {
DragRequest::Begin(request) => {
self.active_drag = Some(ActiveDrag::from_request(request));
invalidations.push(InvalidationRequest::new(
InvalidationTarget::Window(self.id),
InvalidationKind::Paint,
));
}
DragRequest::RefreshTargets => {
self.drag_targets_stale = self.active_drag.is_some();
}
}
}
}
fn is_drag_pointer(&self, pointer: &PointerEvent) -> bool {
self.active_drag
.as_ref()
.is_some_and(|drag| drag.pointer_id == pointer.pointer_id)
}
fn refresh_active_drag(&mut self) -> EventEffects {
let Some(position) = self.active_drag.as_ref().map(|drag| drag.position) else {
return EventEffects::default();
};
let hit_target = self.pointer_hit_target(position);
self.update_active_drag(position, hit_target)
}
fn handle_drag_key_event(
&mut self,
key: &KeyboardEvent,
invalidations: &mut Vec<InvalidationRequest>,
) -> bool {
let Some(drag) = self.active_drag.as_mut() else {
return false;
};
if key.state == KeyState::Pressed && key.key == "Escape" && !key.is_composing {
let position = drag.position;
let effects = self.finish_active_drag(position, true);
self.apply_event_effects(effects, invalidations);
return true;
}
let modifiers = drag_key_modifiers(key);
if drag.modifiers != modifiers {
drag.modifiers = modifiers;
let effects = self.refresh_active_drag();
self.apply_event_effects(effects, invalidations);
}
false
}
fn handle_drag_pointer_event(
&mut self,
pointer: &PointerEvent,
hit_target: Option<WidgetId>,
) -> EventEffects {
if !self.is_drag_pointer(pointer) {
return EventEffects::default();
}
if let Some(drag) = self.active_drag.as_mut() {
drag.modifiers = pointer.modifiers;
}
match pointer.kind {
PointerEventKind::Move => self.update_active_drag(pointer.position, hit_target),
PointerEventKind::Up => {
let mut effects = self.update_active_drag(pointer.position, hit_target);
effects.merge(self.finish_active_drag(pointer.position, false));
effects
}
PointerEventKind::Cancel | PointerEventKind::Leave => {
self.finish_active_drag(pointer.position, true)
}
_ => EventEffects::default(),
}
}
fn update_active_drag(
&mut self,
position: Point,
hit_target: Option<WidgetId>,
) -> EventEffects {
let Some((previous_path, active_snapshot)) = self.active_drag.as_mut().map(|active| {
active.position = position;
(active.hover_path.clone(), active.clone())
}) else {
return EventEffects::default();
};
let next_path = hit_target
.and_then(|target| self.graph.path_to(target))
.unwrap_or_default();
let mut effects = EventEffects::default();
effects.invalidations.push(InvalidationRequest::new(
InvalidationTarget::Window(self.id),
InvalidationKind::Paint,
));
let shared_prefix_len = previous_path
.iter()
.zip(next_path.iter())
.take_while(|(left, right)| left == right)
.count();
for widget_id in previous_path[shared_prefix_len..].iter().rev().copied() {
let event = active_snapshot.event(
DragEventKind::Leave,
position,
Some(widget_id),
DropEffect::None,
None,
);
effects.extend(self.dispatch_direct_event(widget_id, &event));
}
for widget_id in next_path[shared_prefix_len..].iter().copied() {
let event = active_snapshot.event(
DragEventKind::Enter,
position,
Some(widget_id),
DropEffect::None,
None,
);
effects.extend(self.dispatch_direct_event(widget_id, &event));
}
let mut accepted = None;
if let Some(target) = hit_target {
let event = active_snapshot.event(
DragEventKind::Over,
position,
Some(target),
DropEffect::None,
None,
);
let route = self.route_event(target, &event);
accepted = nearest_drop_acceptance(&route.effects.drop_acceptances, &route.path);
if let Some(request) = route.focus_request {
effects.merge(self.apply_focus_request(request));
}
effects.merge(route.effects);
}
if let Some(active) = self.active_drag.as_mut() {
active.hover_path = next_path;
if let Some(accepted) = accepted {
active.accepted_target = Some(accepted.target);
active.accepted_effect = accepted.effect;
} else {
active.accepted_target = None;
active.accepted_effect = DropEffect::None;
}
}
effects
}
fn finish_active_drag(&mut self, position: Point, cancelled: bool) -> EventEffects {
let Some(active) = self.active_drag.take() else {
return EventEffects::default();
};
self.drag_targets_stale = false;
let mut effects = EventEffects::default();
let outcome = if !cancelled {
active
.accepted_target
.filter(|_| active.accepted_effect.is_some())
.map(|target| DragOutcome::Dropped {
target,
effect: active.accepted_effect,
})
.unwrap_or(DragOutcome::Cancelled)
} else {
DragOutcome::Cancelled
};
if let DragOutcome::Dropped { target, effect } = outcome {
let event = active.event(
DragEventKind::Drop,
position,
Some(target),
effect,
Some(outcome),
);
effects.extend(self.dispatch_direct_event(target, &event));
}
for widget_id in active.hover_path.iter().rev().copied() {
let event = active.event(
DragEventKind::Leave,
position,
Some(widget_id),
DropEffect::None,
None,
);
effects.extend(self.dispatch_direct_event(widget_id, &event));
}
let end_event = active.event(
DragEventKind::End,
position,
active.accepted_target,
active.accepted_effect,
Some(outcome),
);
effects.extend(self.dispatch_direct_event(active.source, &end_event));
effects.invalidations.push(InvalidationRequest::new(
InvalidationTarget::Window(self.id),
InvalidationKind::Paint,
));
effects
}
fn apply_wake_requests(&mut self, requests: Vec<WakeRequest>) {
for request in requests {
match request {
WakeRequest::ScheduleTimer {
token,
deadline,
target,
} => {
self.scheduled_timers.retain(|timer| timer.token != token);
self.scheduled_timers.push(ScheduledTimer {
token,
deadline,
target,
});
}
WakeRequest::CancelTimer { token } => {
self.scheduled_timers.retain(|timer| timer.token != token);
self.delivering_timers.remove(&token);
}
WakeRequest::RegisterAsync { token, target } => {
self.async_wake_targets.insert(token, target);
}
WakeRequest::UnregisterAsync { token } => {
self.async_wake_targets.remove(&token);
self.pending_async_wakeups.retain(|queued| *queued != token);
}
WakeRequest::RequestAnimationFrame { target } => {
self.requested_animation_frames.insert(target);
}
WakeRequest::Motion {
target,
kind,
until,
} => {
let end = self.active_motions.entry((target, kind)).or_insert(until);
*end = end.max(until);
}
WakeRequest::MotionEnd {
target,
kind,
until,
} => {
let ends = self.motion_ends.entry((target, kind)).or_default();
if !ends.contains(&until) {
ends.push(until);
}
}
}
}
}
fn apply_pointer_capture_requests(
&mut self,
requests: Vec<PointerCaptureRequest>,
invalidations: &mut Vec<InvalidationRequest>,
) {
for request in requests {
match request {
PointerCaptureRequest::Capture { pointer_id, target } => {
self.reconcile_pointer_capture(pointer_id, Some(target), invalidations);
}
PointerCaptureRequest::Release { pointer_id } => {
self.pointer_capture.remove(&pointer_id);
}
}
}
}
fn apply_cursor_requests(&mut self, requests: Vec<CursorRequest>) {
for request in requests {
match request {
CursorRequest::Grab { target, mode } => {
if !self.focus.window_focused && mode != CursorGrabMode::None {
continue;
}
if mode == CursorGrabMode::None {
if self.cursor.grab_owner.is_some()
&& self.cursor.grab_owner != Some(target)
{
continue;
}
self.cursor.grab_owner = None;
} else {
self.cursor.grab_owner = Some(target);
}
self.cursor.state.grab_mode = mode;
self.cursor.state.revision = self.cursor.state.revision.wrapping_add(1);
}
CursorRequest::Visibility { target, visible } => {
if !self.focus.window_focused && !visible {
continue;
}
if visible {
if self.cursor.visibility_owner.is_some()
&& self.cursor.visibility_owner != Some(target)
{
continue;
}
self.cursor.visibility_owner = None;
} else {
self.cursor.visibility_owner = Some(target);
}
self.cursor.state.visible = visible;
self.cursor.state.revision = self.cursor.state.revision.wrapping_add(1);
}
}
}
}
fn reset_cursor_state(&mut self) {
if self.cursor.state.grab_mode == CursorGrabMode::None
&& self.cursor.state.visible
&& self.cursor.grab_owner.is_none()
&& self.cursor.visibility_owner.is_none()
{
return;
}
self.cursor.state.grab_mode = CursorGrabMode::None;
self.cursor.state.visible = true;
self.cursor.state.revision = self.cursor.state.revision.wrapping_add(1);
self.cursor.grab_owner = None;
self.cursor.visibility_owner = None;
}
fn cancel_all_pointer_captures(&mut self, invalidations: &mut Vec<InvalidationRequest>) {
let pointer_ids = self.pointer_capture.keys().copied().collect::<Vec<_>>();
for pointer_id in pointer_ids {
self.reconcile_pointer_capture(pointer_id, None, invalidations);
}
}
fn reconcile_pointer_capture(
&mut self,
pointer_id: u64,
requested_target: Option<WidgetId>,
invalidations: &mut Vec<InvalidationRequest>,
) {
let mut cancelled_owners = HashSet::new();
loop {
let current = self.pointer_capture.get(&pointer_id).copied();
match (current, requested_target) {
(None, Some(target)) => {
self.pointer_capture.insert(pointer_id, target);
return;
}
(None, None) => return,
(Some(owner), Some(target)) if owner == target => return,
(Some(owner), _) => {
self.pointer_capture.remove(&pointer_id);
if !cancelled_owners.insert(owner) {
continue;
}
let cancel = self.pointer_cancel_event(pointer_id);
let dispatch = self.dispatch_direct_event(owner, &Event::Pointer(cancel));
self.apply_pointer_cancel_dispatch(dispatch, invalidations);
}
}
}
}
fn pointer_cancel_event(&self, pointer_id: u64) -> PointerEvent {
let mut pointer = self
.last_pointer_events
.get(&pointer_id)
.cloned()
.unwrap_or_else(|| PointerEvent::new(PointerEventKind::Cancel, Point::ZERO));
pointer.pointer_id = pointer_id;
pointer.kind = PointerEventKind::Cancel;
pointer.delta = Vector::ZERO;
pointer.scroll_delta = None;
pointer.button = None;
pointer.buttons = PointerButtons::NONE;
pointer
}
fn apply_pointer_cancel_dispatch(
&mut self,
dispatch: widget::EventDispatch,
invalidations: &mut Vec<InvalidationRequest>,
) {
let focus_request = dispatch.focus_request;
let mut effects = EventEffects::default();
effects.extend(dispatch);
self.apply_event_effects(effects, invalidations);
if let Some(request) = focus_request {
let focus_effects = self.apply_focus_request(request);
self.apply_event_effects(focus_effects, invalidations);
}
}
fn release_ime_hold(&mut self) {
if self.touches_down.is_empty()
&& self.held_ime_composition_rect.take().is_some()
&& self.ime_composition_rect.is_none()
{
self.schedule.mark(InvalidationKind::Paint);
}
}
fn finish_event(&mut self, event: &Event) {
match event {
Event::Pointer(pointer)
if matches!(
pointer.kind,
PointerEventKind::Up | PointerEventKind::Cancel
) =>
{
self.pointer_capture.remove(&pointer.pointer_id);
self.last_pointer_events.remove(&pointer.pointer_id);
if self.touches_down.remove(&pointer.pointer_id) {
self.release_ime_hold();
}
}
Event::Wake(WakeEvent::Timer { token, .. }) => {
self.delivering_timers.remove(token);
}
Event::Wake(WakeEvent::AnimationFrame { .. }) => {
self.delivering_animation_frames.pop_front();
if self.delivering_animation_frames.is_empty() && !self.wants_animation_frame() {
self.last_animation_frame_time = None;
}
}
_ => {}
}
}
fn route_event(&mut self, target: WidgetId, event: &Event) -> EventRouteResult {
let path = self
.graph
.path_to(target)
.unwrap_or_else(|| vec![self.root.id()]);
let dpi_info = self.current_dpi_info();
let mut effects = EventEffects::default();
let mut handled = false;
let mut focus_request = None;
let mut route_steps = self.inspector_tracing_enabled.then(Vec::new);
let target_only = matches!(event, Event::Wake(_));
let ignore_handled = matches!(event, Event::Drag(_));
if !target_only && path.len() > 1 {
for path_len in 1..path.len() {
let dispatch = self
.root
.dispatch_event_for_path(
&path[..path_len],
self.id,
dpi_info,
self.last_tick_time,
EventPhase::Capture,
self.focus.focused_widget,
&self.services,
&self.command_sender,
event,
)
.unwrap_or_else(empty_dispatch);
let dispatch_handled = dispatch.handled;
let dispatch_focus_request = dispatch.focus_request;
if let Some(route_steps) = &mut route_steps {
route_steps.push(EventRouteStep {
widget_id: path[path_len - 1],
phase: EventRoutePhase::Capture,
handled: dispatch_handled,
});
}
effects.extend(dispatch);
if dispatch_focus_request.is_some() {
focus_request = dispatch_focus_request;
}
if dispatch_handled && !ignore_handled {
handled = true;
break;
}
}
}
if !handled || ignore_handled {
let dispatch = self
.root
.dispatch_event_for_path(
&path,
self.id,
dpi_info,
self.last_tick_time,
EventPhase::Target,
self.focus.focused_widget,
&self.services,
&self.command_sender,
event,
)
.or_else(|| {
self.root.dispatch_event_for(
target,
self.id,
dpi_info,
self.last_tick_time,
EventPhase::Target,
self.focus.focused_widget,
&self.services,
&self.command_sender,
event,
)
})
.unwrap_or_else(empty_dispatch);
let dispatch_handled = dispatch.handled;
let dispatch_focus_request = dispatch.focus_request;
if let Some(route_steps) = &mut route_steps {
route_steps.push(EventRouteStep {
widget_id: target,
phase: EventRoutePhase::Target,
handled: dispatch_handled,
});
}
effects.extend(dispatch);
if dispatch_focus_request.is_some() {
focus_request = dispatch_focus_request;
}
handled = dispatch_handled && !ignore_handled;
}
if !target_only && (!handled || ignore_handled) && path.len() > 1 {
for path_len in (1..path.len()).rev() {
let dispatch = self
.root
.dispatch_event_for_path(
&path[..path_len],
self.id,
dpi_info,
self.last_tick_time,
EventPhase::Bubble,
self.focus.focused_widget,
&self.services,
&self.command_sender,
event,
)
.unwrap_or_else(empty_dispatch);
let dispatch_handled = dispatch.handled;
let dispatch_focus_request = dispatch.focus_request;
if let Some(route_steps) = &mut route_steps {
route_steps.push(EventRouteStep {
widget_id: path[path_len - 1],
phase: EventRoutePhase::Bubble,
handled: dispatch_handled,
});
}
effects.extend(dispatch);
if dispatch_focus_request.is_some() {
focus_request = dispatch_focus_request;
}
if dispatch_handled && !ignore_handled {
handled = true;
break;
}
}
}
if let Some(route_steps) = route_steps {
let trace_handled = route_steps.iter().any(|step| step.handled);
let sample = EventRouteTraceSample {
sequence: self.next_event_route_sequence,
event_kind: inspector_event_kind(event),
target,
path: path.clone(),
steps: route_steps,
handled: trace_handled,
};
self.next_event_route_sequence = self.next_event_route_sequence.wrapping_add(1);
push_inspector_history(&mut self.event_route_history, sample);
}
EventRouteResult {
path,
effects,
focus_request,
handled,
}
}
fn default_focus_request(
&self,
event: &Event,
hit_target: Option<WidgetId>,
path: &[WidgetId],
) -> Option<FocusRequest> {
match event {
Event::Keyboard(keyboard)
if keyboard.state == KeyState::Pressed
&& keyboard.key == "Tab"
&& !keyboard.repeat
&& !keyboard.is_composing
&& !keyboard.modifiers.control
&& !keyboard.modifiers.alt
&& !keyboard.modifiers.meta =>
{
self.overlay_manager
.focus_trap()
.and_then(|scope| {
self.graph.next_focusable_within(
scope,
self.focus.focused_widget,
keyboard.modifiers.shift,
)
})
.or_else(|| {
self.graph
.next_focusable(self.focus.focused_widget, keyboard.modifiers.shift)
})
.map(FocusRequest::Focus)
.or(Some(FocusRequest::Clear))
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Down => {
let Some(hit_target) = hit_target else {
return Some(FocusRequest::Clear);
};
path.iter()
.rev()
.copied()
.find(|widget_id| {
self.graph
.node(*widget_id)
.is_some_and(|node| node.accepts_focus)
})
.map(FocusRequest::Focus)
.or(Some(FocusRequest::Clear))
.filter(|request| {
matches!(request, FocusRequest::Focus(id) if *id == hit_target)
|| matches!(request, FocusRequest::Clear)
})
}
Event::Window(WindowEvent::Focused(false)) => Some(FocusRequest::Clear),
_ => None,
}
}
fn apply_focus_request(&mut self, request: FocusRequest) -> EventEffects {
let request = self.constrain_focus_request(request);
self.apply_focus_request_unconstrained(request)
}
fn apply_focus_request_unconstrained(&mut self, request: FocusRequest) -> EventEffects {
let next_focus = match request {
FocusRequest::Focus(widget_id) => Some(widget_id),
FocusRequest::Clear => None,
FocusRequest::Keep => return EventEffects::default(),
};
if self.focus.focused_widget == next_focus {
if self.focused_semantics != next_focus {
self.focused_semantics = next_focus;
self.schedule.mark(InvalidationKind::Semantics);
}
return EventEffects::default();
}
let previous_focus = self.focus.focused_widget;
self.focus.focused_widget = next_focus;
self.focused_semantics = next_focus;
let dpi_info = self.current_dpi_info();
let mut effects = EventEffects::default();
if let Some(widget_id) = previous_focus {
effects
.invalidations
.extend(self.focus_transition_invalidations(widget_id));
let extra = self
.graph
.path_to(widget_id)
.and_then(|path| {
self.root.notify_focus_change_for_path(
&path,
self.id,
dpi_info,
self.last_tick_time,
self.focus.focused_widget,
&self.services,
&self.command_sender,
false,
)
})
.or_else(|| {
self.root.notify_focus_change_for(
widget_id,
self.id,
dpi_info,
self.last_tick_time,
self.focus.focused_widget,
&self.services,
&self.command_sender,
false,
)
});
if let Some(extra) = extra {
effects.extend(extra);
}
}
if let Some(widget_id) = next_focus {
effects
.invalidations
.extend(self.focus_transition_invalidations(widget_id));
let extra = self
.graph
.path_to(widget_id)
.and_then(|path| {
self.root.notify_focus_change_for_path(
&path,
self.id,
dpi_info,
self.last_tick_time,
self.focus.focused_widget,
&self.services,
&self.command_sender,
true,
)
})
.or_else(|| {
self.root.notify_focus_change_for(
widget_id,
self.id,
dpi_info,
self.last_tick_time,
self.focus.focused_widget,
&self.services,
&self.command_sender,
true,
)
});
if let Some(extra) = extra {
effects.extend(extra);
}
}
self.schedule.mark(InvalidationKind::Paint);
self.schedule.mark(InvalidationKind::Semantics);
self.schedule.mark(InvalidationKind::HitTest);
self.graph.set_focused_widget(self.focus.focused_widget);
effects
}
fn constrain_focus_request(&self, request: FocusRequest) -> FocusRequest {
let Some(scope) = self.overlay_manager.focus_trap() else {
return request;
};
match request {
FocusRequest::Focus(widget_id)
if widget_id == scope || self.graph.is_ancestor_of(scope, widget_id) =>
{
return request;
}
FocusRequest::Keep => return request,
FocusRequest::Focus(_) | FocusRequest::Clear => {}
}
self.focus
.focused_widget
.filter(|focused| *focused == scope || self.graph.is_ancestor_of(scope, *focused))
.or_else(|| self.graph.first_focusable_within(scope, true))
.map(FocusRequest::Focus)
.unwrap_or(FocusRequest::Clear)
}
fn apply_pending_overlay_focus(&mut self, invalidations: &mut Vec<InvalidationRequest>) {
let Some(request) = self.pending_overlay_focus.take() else {
return;
};
let effects = self.apply_focus_request(request);
self.apply_event_effects(effects, invalidations);
}
fn focus_transition_invalidations(&self, widget_id: WidgetId) -> Vec<InvalidationRequest> {
let mut invalidations = vec![InvalidationRequest::new(
InvalidationTarget::Widget(widget_id),
InvalidationKind::Semantics,
)];
if let Some(node) = self.graph.node(widget_id) {
invalidations.push(
InvalidationRequest::new(
InvalidationTarget::Widget(widget_id),
InvalidationKind::Paint,
)
.with_region(node.geometry.paint_bounds),
);
}
invalidations
}
fn render(
&mut self,
text_system: Arc<TextSystem>,
font_registry: Arc<FontRegistry>,
image_registry: Arc<ImageRegistry>,
) -> RenderOutput {
let diagnostics_enabled = window_scene_statistics_detail_mode(self.id).is_detailed();
let mut diagnostics = RenderDiagnostics::default();
let mut invalidations = std::mem::take(&mut self.pending_invalidations);
let local_output = std::mem::take(&mut self.pending_local_output);
let mut repainted = false;
let mut repaint_layers = Vec::new();
let mut dirty_layers = Vec::new();
let mut layer_updates = Vec::new();
let root_repaint_covers_graph_changes =
root_repaint_covers_graph_changes(self.root.id(), &invalidations);
let diff_graph = !root_repaint_covers_graph_changes
&& (self.previous_graph_saved
|| ((self.schedule.measure || self.schedule.arrange) && !self.graph.is_empty()));
let mut graph_changes = GraphChangeSet::default();
if self.schedule.measure || self.schedule.arrange || self.viewport.is_none() {
let started = Instant::now();
let pass_invalidations = self.run_measure_arrange_pass(
&invalidations,
Arc::clone(&text_system),
Arc::clone(&font_registry),
Arc::clone(&image_registry),
);
self.schedule.extend(&pass_invalidations);
invalidations.extend(pass_invalidations);
graph_changes = if root_repaint_covers_graph_changes {
GraphChangeSet::default()
} else {
self.collect_graph_changes(
(diff_graph && self.previous_graph_saved).then_some(&self.previous_graph),
)
};
if diagnostics_enabled {
diagnostics.push(FramePhase::MeasureArrange, started.elapsed());
}
} else {
if self.schedule.hit_test || self.graph.is_empty() {
let started = Instant::now();
self.refresh_graph();
if diagnostics_enabled {
diagnostics.push(FramePhase::HitTest, started.elapsed());
}
}
if diff_graph && self.previous_graph_saved {
graph_changes = self.collect_graph_changes(Some(&self.previous_graph));
}
}
self.previous_graph_saved = false;
self.apply_pending_overlay_focus(&mut invalidations);
let viewport = self.viewport.unwrap_or(Size::ZERO);
let dpi_info = self.dpi_info_for_viewport(viewport);
self.prepare_output_reuse(
&invalidations,
&local_output,
&graph_changes,
dpi_info,
Arc::clone(&font_registry),
Arc::clone(&image_registry),
);
let previous_scene = self.last_frame.as_ref().map(|frame| &frame.scene);
let mut composition_only_transforms = self
.select_composition_only_transforms(previous_scene, &graph_changes.transform_widgets);
for translation in
self.select_explicit_transform_translations(previous_scene, &invalidations)
{
if composition_only_transforms
.iter()
.all(|existing| existing.widget_id != translation.widget_id)
{
composition_only_transforms.push(translation);
}
}
let previous_scene_for_refresh = self.last_frame.as_ref().map(|frame| frame.scene.clone());
let layer_descriptor_refreshes = self.collect_explicit_layer_descriptor_refreshes(
previous_scene_for_refresh.as_ref(),
&invalidations,
);
let composition_only_transform_ids = composition_only_transforms
.iter()
.map(|translation| translation.widget_id)
.collect::<HashSet<_>>();
let mut repaint_graph_widgets = graph_changes.repaint_widgets.clone();
for translation in &graph_changes.transform_widgets {
if !composition_only_transform_ids.contains(&translation.widget_id) {
repaint_graph_widgets.push(translation.widget_id);
}
}
if self.schedule.paint || self.last_frame.is_none() || !repaint_graph_widgets.is_empty() {
repaint_layers = self.collect_dirty_layers(&invalidations);
dirty_layers = repaint_layers.clone();
for widget_id in repaint_graph_widgets.iter().copied() {
if self.graph.contains(widget_id) && !dirty_layers.contains(&widget_id) {
dirty_layers.push(widget_id);
}
if self.graph.contains(widget_id) && !repaint_layers.contains(&widget_id) {
repaint_layers.push(widget_id);
}
}
let mixed_update_roots = composition_only_transforms
.iter()
.filter(|translation| {
dirty_layers.iter().any(|dirty_widget| {
self.widget_is_ancestor_of(translation.widget_id, *dirty_widget)
})
})
.map(|translation| translation.widget_id)
.collect::<Vec<_>>();
repaint_layers.extend(mixed_update_roots.iter().copied());
dirty_layers.extend(mixed_update_roots);
self.minimize_layer_roots(&mut repaint_layers);
self.minimize_layer_roots(&mut dirty_layers);
composition_only_transforms.retain(|translation| {
!dirty_layers.iter().any(|dirty_widget| {
*dirty_widget == translation.widget_id
|| self.widget_is_ancestor_of(*dirty_widget, translation.widget_id)
})
});
}
let mut scene_changed = false;
let has_ordering_updates = invalidations
.iter()
.any(|request| request.kind == InvalidationKind::Ordering);
if self.last_frame.is_none()
|| !repaint_layers.is_empty()
|| !composition_only_transforms.is_empty()
|| !layer_descriptor_refreshes.is_empty()
|| has_ordering_updates
{
let started = Instant::now();
repainted = self.last_frame.is_none() || !repaint_layers.is_empty();
scene_changed = true;
let focused_path = self
.focus
.focused_widget
.and_then(|widget_id| self.graph.path_to(widget_id));
let preserve_ime = focused_path.as_ref().is_none_or(|path| {
!repaint_layers
.iter()
.any(|widget_id| path.iter().any(|candidate| candidate == widget_id))
});
let baseline_ime_composition_rect = if preserve_ime {
self.ime_composition_rect
} else {
None
};
let (scene, paint_images, mut paint_bounds_by_widget, mut ime_composition_rect) =
if self.last_frame.is_none() || repaint_layers.contains(&self.root.id()) {
self.paint_full_scene(
dpi_info,
Arc::clone(&text_system),
Arc::clone(&font_registry),
Arc::clone(&image_registry),
)
} else if repaint_layers.is_empty() {
(
self.last_frame
.as_ref()
.map(|frame| frame.scene.clone())
.unwrap_or_default(),
Vec::new(),
self.last_paint_bounds_by_widget.clone(),
baseline_ime_composition_rect,
)
} else {
self.repaint_dirty_layers(
dpi_info,
&repaint_layers,
baseline_ime_composition_rect,
Arc::clone(&text_system),
Arc::clone(&font_registry),
Arc::clone(&image_registry),
)
};
let mut scene = scene;
for translation in &composition_only_transforms {
let _ = scene.translate_layer(translation.widget_id, translation.delta);
for widget_id in self.graph.subtree_ids(translation.widget_id) {
if let Some(bounds) = paint_bounds_by_widget.get_mut(&widget_id) {
*bounds = bounds.translate(translation.delta);
}
}
if let Some(moved_bounds) =
paint_bounds_by_widget.get(&translation.widget_id).copied()
{
let mut ancestor = self
.graph
.node(translation.widget_id)
.and_then(|node| node.parent);
while let Some(widget_id) = ancestor {
paint_bounds_by_widget
.entry(widget_id)
.and_modify(|bounds| *bounds = bounds.union(moved_bounds))
.or_insert(moved_bounds);
ancestor = self.graph.node(widget_id).and_then(|node| node.parent);
}
}
if focused_path
.as_ref()
.is_some_and(|path| path.contains(&translation.widget_id))
{
ime_composition_rect =
ime_composition_rect.map(|rect| rect.translate(translation.delta));
}
}
for refresh in &layer_descriptor_refreshes {
let _ =
scene.replace_layer_descriptor(refresh.widget_id, refresh.descriptor.clone());
}
self.sync_scene_stack_metadata(&mut scene);
self.last_paint_bounds_by_widget = paint_bounds_by_widget;
self.graph
.update_paint_bounds_from_snapshot(&self.last_paint_bounds_by_widget);
self.ime_composition_rect = ime_composition_rect;
let previous_scene = self.last_frame.as_ref().map(|frame| &frame.scene);
layer_updates = self.collect_layer_updates(
previous_scene,
&scene,
&invalidations,
&dirty_layers,
&composition_only_transforms
.iter()
.map(|translation| translation.widget_id)
.collect::<Vec<_>>(),
);
let frame_image_registry =
self.frame_image_registry(Arc::clone(&image_registry), paint_images);
if text_system.text_layout_registry().len()
> self.retained_text_layout_count + TEXT_LAYOUT_PRUNE_SLACK
{
retain_text_layouts_for_scene(text_system.as_ref(), &scene);
self.retained_text_layout_count = text_system.text_layout_registry().len();
}
self.last_frame = Some(SceneFrame {
window_id: self.id,
viewport,
surface_size: dpi_info.surface_size,
scale_factor: dpi_info.scale_factor,
dirty_regions: Vec::new(),
layer_updates: layer_updates.clone(),
scene,
font_registry: Arc::clone(&font_registry),
image_registry: frame_image_registry,
text_layout_registry: text_system.text_layout_registry(),
});
if diagnostics_enabled && repainted {
diagnostics.push(FramePhase::Paint, started.elapsed());
}
}
if self.schedule.semantics || self.last_semantics.is_empty() {
let started = Instant::now();
let mut semantics_ctx = SemanticsCtx::new(
self.id,
self.root.id(),
self.root.id(),
self.root.bounds(),
self.focus.focused_widget,
);
semantics_ctx.output_cache = output_cache::OutputCache::scope(&self.output_cache);
self.root.semantics(&mut semantics_ctx);
let semantics = self.assemble_semantics_tree(semantics_ctx.into_nodes());
self.last_semantics = self.filter_modal_semantics(semantics);
if diagnostics_enabled {
diagnostics.push(FramePhase::Semantics, started.elapsed());
}
}
let viewport_rect = Rect::from_origin_size(Point::ZERO, viewport);
let dirty_regions = collect_dirty_regions(viewport, &invalidations, repainted, |request| {
self.default_dirty_region_for_request(viewport_rect, request)
});
let mut frame = self
.last_frame
.clone()
.unwrap_or_else(|| SceneFrame::new(self.id, viewport));
frame.viewport = viewport;
frame.surface_size = dpi_info.surface_size;
frame.scale_factor = dpi_info.scale_factor;
frame.dirty_regions = dirty_regions;
frame.layer_updates = if scene_changed {
layer_updates
} else {
self.collect_layer_updates(
self.last_frame.as_ref().map(|stored| &stored.scene),
&frame.scene,
&invalidations,
&[],
&composition_only_transforms
.iter()
.map(|translation| translation.widget_id)
.collect::<Vec<_>>(),
)
};
frame.font_registry = font_registry;
frame.image_registry = self.frame_image_registry(image_registry, Vec::new());
if diagnostics_enabled {
let layout_cache = text_system.layout_cache_snapshot();
diagnostics.text_caches.runtime_layout =
CacheMetrics::new(layout_cache.entries, layout_cache.hits, layout_cache.misses);
}
diagnostics.widget_count = self.graph.nodes.len();
diagnostics.runtime_text_timing = sui_text::take_text_timing_collection();
diagnostics.widget_timings = diagnostics::take_widget_timing_collection();
diagnostics.reactive_invalidations = std::mem::take(&mut self.pending_reactive_diagnostics);
diagnostics.command_dispatches = std::mem::take(&mut self.pending_command_diagnostics);
diagnostics.invalidations = std::mem::take(&mut self.pending_invalidation_diagnostics);
diagnostics.widget_rebuilds = diagnostics::take_widget_rebuilds(self.id);
diagnostics.active_animated_widget_count = self.active_animated_widget_count();
diagnostics.animation_frame_wake_count = self.pending_animation_wake_count;
diagnostics.animation_repaint_frame_count =
usize::from(self.pending_animation_wake_count > 0 && repainted);
diagnostics.animation_transform_effect_only_frame_count = usize::from(
self.pending_animation_wake_count > 0
&& self.animation_frame_is_transform_only(repainted, &frame.layer_updates),
);
self.pending_animation_wake_count = 0;
self.capture_inspector_diagnostics(&diagnostics);
self.schedule.clear();
RenderOutput {
title: self.title.clone(),
frame,
semantics: self.last_semantics.clone(),
ime_composition_rect: self.ime_composition_rect.or(self.held_ime_composition_rect),
diagnostics,
}
}
fn frame_image_registry(
&mut self,
base: Arc<ImageRegistry>,
paint_images: Vec<(ImageHandle, PaintImageResource)>,
) -> Arc<ImageRegistry> {
if paint_images.is_empty()
&& self
.last_image_registry_base
.as_ref()
.is_some_and(|last| Arc::ptr_eq(last, &base))
&& let Some(frame) = &self.last_frame
{
return Arc::clone(&frame.image_registry);
}
self.last_image_registry_base = Some(Arc::clone(&base));
let mut registry = self
.last_frame
.as_ref()
.map(|frame| frame.image_registry.as_ref().clone())
.unwrap_or_else(|| base.as_ref().clone());
for (handle, image) in base.iter() {
registry.insert(handle, image.clone());
}
for (handle, image) in base.iter_external() {
registry.insert_external(handle, *image);
}
for (handle, image) in paint_images {
match image {
PaintImageResource::Cpu(image) => {
registry.insert(handle, image);
}
PaintImageResource::External(image) => {
registry.insert_external(handle, image);
}
}
}
Arc::new(registry)
}
fn prepare_output_reuse(
&mut self,
invalidations: &[InvalidationRequest],
local_output: &HashMap<(WidgetId, InvalidationKind), usize>,
changes: &GraphChangeSet,
dpi: DpiInfo,
fonts: Arc<FontRegistry>,
images: Arc<ImageRegistry>,
) {
if invalidations.is_empty()
&& changes.output_widgets.is_empty()
&& !self.schedule.paint
&& !self.schedule.semantics
{
self.output_cache.borrow_mut().next_frame();
return;
}
let mut cache = self.output_cache.borrow_mut();
cache.next_frame();
cache.context(
dpi,
self.focus.focused_widget,
fonts,
images,
window_render_options(self.id),
);
if self.last_frame.is_none() {
cache.clear();
return;
}
let mut explicit_full_paint = false;
let mut explicit_full_semantics = false;
for request in invalidations {
let full = match request.target {
InvalidationTarget::Widget(id) => {
id == self.root.id() && !local_output.contains_key(&(id, request.kind))
}
_ => true,
};
if full {
match request.kind {
InvalidationKind::Paint | InvalidationKind::Effect => {
explicit_full_paint = true
}
InvalidationKind::Semantics => explicit_full_semantics = true,
_ => {
explicit_full_paint = true;
explicit_full_semantics = true;
}
}
}
}
if (explicit_full_paint && explicit_full_semantics)
|| (!changes.output_widgets.is_empty()
&& changes.output_widgets.len().saturating_mul(2) >= self.graph.nodes.len())
{
cache.disable_paint();
cache.disable_semantics();
return;
}
let mut counts = HashMap::<_, usize>::new();
for request in invalidations {
if let InvalidationTarget::Widget(id) = request.target
&& local_output.contains_key(&(id, request.kind))
{
*counts.entry((id, request.kind)).or_default() += 1;
}
}
let mut paint_dirty = HashSet::new();
let mut semantics_dirty = HashSet::new();
let mut full_paint = invalidations.is_empty() && self.schedule.paint;
let mut full_semantics = invalidations.is_empty() && self.schedule.semantics;
for id in &changes.output_widgets {
paint_dirty.insert(*id);
semantics_dirty.insert(*id);
if let Some(path) = self.graph.path_to(*id) {
paint_dirty.extend(path.iter().copied());
semantics_dirty.extend(path);
}
}
for request in invalidations {
let (paint, semantics) = match request.kind {
InvalidationKind::Paint | InvalidationKind::Effect => (true, false),
InvalidationKind::Semantics => (false, true),
_ => (true, true),
};
let InvalidationTarget::Widget(id) = request.target else {
full_paint |= paint;
full_semantics |= semantics;
continue;
};
let local = local_output
.get(&(id, request.kind))
.is_some_and(|count| counts.get(&(id, request.kind)) == Some(count));
if !self.graph.contains(id) || (id == self.root.id() && !local) {
full_paint |= paint;
full_semantics |= semantics;
continue;
}
let nodes = if local {
vec![id]
} else {
self.graph.subtree_ids(id)
};
if paint {
paint_dirty.extend(nodes.iter().copied());
}
if semantics {
semantics_dirty.extend(nodes);
}
if let Some(path) = self.graph.path_to(id) {
if paint {
paint_dirty.extend(path.iter().copied());
}
if semantics {
semantics_dirty.extend(path);
}
}
}
if full_paint || paint_dirty.len().saturating_mul(2) >= self.graph.nodes.len() {
cache.disable_paint();
}
if full_semantics || semantics_dirty.len().saturating_mul(2) >= self.graph.nodes.len() {
cache.disable_semantics();
}
cache.retain(
|id| self.graph.contains(id) && !paint_dirty.contains(&id),
|id| self.graph.contains(id) && !semantics_dirty.contains(&id),
);
}
fn paint_full_scene(
&mut self,
dpi_info: DpiInfo,
text_system: Arc<TextSystem>,
font_registry: Arc<FontRegistry>,
image_registry: Arc<ImageRegistry>,
) -> PaintOutput {
let mut paint_ctx = PaintCtx::new(
self.id,
self.root.id(),
self.root.bounds(),
self.focus.focused_widget,
dpi_info,
text_system,
font_registry,
self.last_frame
.as_ref()
.map(|frame| Arc::clone(&frame.image_registry))
.unwrap_or(image_registry),
)
.with_frame_time(self.frame_time());
paint_ctx.output_cache = output_cache::OutputCache::scope(&self.output_cache);
let _ = self
.root
.paint_layer_contents_for(self.root.id(), &mut paint_ctx);
paint_ctx.into_parts()
}
fn repaint_dirty_layers(
&mut self,
dpi_info: DpiInfo,
dirty_layers: &[WidgetId],
baseline_ime_composition_rect: Option<Rect>,
text_system: Arc<TextSystem>,
font_registry: Arc<FontRegistry>,
image_registry: Arc<ImageRegistry>,
) -> PaintOutput {
let mut scene = self
.last_frame
.as_ref()
.map(|frame| frame.scene.clone())
.unwrap_or_default();
let mut images = Vec::new();
let mut paint_bounds_by_widget = self.last_paint_bounds_by_widget.clone();
let mut ime_composition_rect = baseline_ime_composition_rect;
let frame_time = self.frame_time();
for &widget_id in dirty_layers {
let Some(bounds) = self
.graph
.node(widget_id)
.map(|node| node.geometry.layout_bounds)
else {
return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
};
let mut paint_ctx = PaintCtx::new(
self.id,
widget_id,
bounds,
self.focus.focused_widget,
dpi_info,
Arc::clone(&text_system),
Arc::clone(&font_registry),
self.last_frame
.as_ref()
.map(|frame| Arc::clone(&frame.image_registry))
.unwrap_or_else(|| Arc::clone(&image_registry)),
)
.with_frame_time(self.frame_time());
paint_ctx.output_cache = output_cache::OutputCache::scope(&self.output_cache);
if !self
.root
.paint_layer_contents_for(widget_id, &mut paint_ctx)
{
return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
}
let (layer_scene, layer_images, layer_paint_bounds, layer_ime_composition_rect) =
paint_ctx.into_parts();
let Some(descriptor) =
self.root
.layer_descriptor_for(widget_id, &layer_scene, frame_time)
else {
return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
};
if widget_id == self.root.id()
|| !scene.replace_layer(
widget_id,
SceneLayer::from_descriptor(descriptor, layer_scene),
)
{
return self.paint_full_scene(dpi_info, text_system, font_registry, image_registry);
}
images.extend(layer_images);
paint_bounds_by_widget.extend(layer_paint_bounds);
if layer_ime_composition_rect.is_some() {
ime_composition_rect = layer_ime_composition_rect;
}
}
(scene, images, paint_bounds_by_widget, ime_composition_rect)
}
fn collect_dirty_layers(&self, invalidations: &[InvalidationRequest]) -> Vec<WidgetId> {
let candidates: HashSet<WidgetId> = invalidations
.iter()
.filter(|request| {
matches!(
request.kind,
InvalidationKind::Measure
| InvalidationKind::Clip
| InvalidationKind::Visibility
| InvalidationKind::Paint
| InvalidationKind::Text
| InvalidationKind::Resources
)
})
.map(|request| match request.target {
InvalidationTarget::Widget(widget_id) if self.graph.contains(widget_id) => self
.graph
.nearest_paint_boundary_ancestor_or_root(widget_id),
InvalidationTarget::Widget(_) => self.root.id(),
InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => self.root.id(),
})
.collect();
if self.last_frame.is_none() || candidates.contains(&self.root.id()) {
return vec![self.root.id()];
}
let mut candidates: Vec<_> = candidates
.into_iter()
.filter(|widget_id| self.graph.contains(*widget_id))
.collect();
candidates.sort_by_key(|widget_id| {
self.graph
.path_to(*widget_id)
.map_or(usize::MAX, |path| path.len())
});
let mut minimized = Vec::new();
for widget_id in candidates {
if minimized
.iter()
.any(|ancestor| self.widget_is_ancestor_of(*ancestor, widget_id))
{
continue;
}
minimized.push(widget_id);
}
minimized
}
fn collect_graph_changes(&self, previous: Option<&WidgetGraph>) -> GraphChangeSet {
let Some(previous) = previous else {
return GraphChangeSet {
output_widgets: vec![self.graph.root],
repaint_widgets: vec![self.graph.root],
transform_widgets: Vec::new(),
};
};
let previous_nodes = &previous.nodes;
let current_nodes = &self.graph.nodes;
let current_root = self.graph.root;
let widget_ids = self.graph.order.iter().copied().chain(
previous
.order
.iter()
.copied()
.filter(|widget_id| !current_nodes.contains_key(widget_id)),
);
let mut output_widgets = Vec::new();
let mut repaint_candidates = HashSet::new();
let mut transform_candidates = Vec::new();
for widget_id in widget_ids {
match (
previous_nodes.get(&widget_id),
current_nodes.get(&widget_id),
) {
(Some(previous_node), Some(current_node)) => {
if previous_node.measured_size != current_node.measured_size
|| previous_node.geometry.layout_bounds.size
!= current_node.geometry.layout_bounds.size
|| previous_node.parent != current_node.parent
|| previous_node.children != current_node.children
{
output_widgets.push(current_node.id);
repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
current_nodes,
current_root,
current_node.id,
));
continue;
}
let delta = current_node.geometry.layout_bounds.origin
- previous_node.geometry.layout_bounds.origin;
if delta != Vector::ZERO
|| previous_node.geometry.input_bounds != current_node.geometry.input_bounds
{
output_widgets.push(current_node.id);
}
if delta != Vector::ZERO {
let resolved_boundary = resolve_snapshot_paint_boundary_or_root(
current_nodes,
current_root,
current_node.id,
);
if resolved_boundary == current_node.id
&& current_node.paint_boundary == PaintBoundaryMode::Explicit
{
transform_candidates.push(LayerTranslation {
widget_id: current_node.id,
delta,
});
} else if current_nodes
.get(&resolved_boundary)
.zip(previous_nodes.get(&resolved_boundary))
.is_some_and(|(current_boundary, previous_boundary)| {
current_boundary.paint_boundary == PaintBoundaryMode::Explicit
&& same_layer_translation(
current_boundary.geometry.layout_bounds.origin
- previous_boundary.geometry.layout_bounds.origin,
delta,
)
})
{
} else {
repaint_candidates.insert(resolved_boundary);
}
}
}
(None, Some(current_node)) => {
output_widgets.push(current_node.id);
repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
current_nodes,
current_root,
current_node.id,
));
}
(Some(previous_node), None) => {
repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
previous_nodes,
previous.root,
previous_node.id,
));
}
(None, None) => {}
}
}
let mut repaint_widgets = repaint_candidates.into_iter().collect::<Vec<_>>();
repaint_widgets.sort_by_key(|widget_id| self.widget_depth(*widget_id));
let mut minimized_repaint = Vec::new();
for widget_id in repaint_widgets {
if minimized_repaint
.iter()
.any(|ancestor| self.widget_is_ancestor_of(*ancestor, widget_id))
{
continue;
}
minimized_repaint.push(widget_id);
}
transform_candidates.sort_by_key(|translation| self.widget_depth(translation.widget_id));
let mut minimized_transforms = Vec::new();
for candidate in transform_candidates {
if minimized_repaint
.iter()
.any(|ancestor| self.widget_is_ancestor_of(*ancestor, candidate.widget_id))
{
continue;
}
let inherited_delta = minimized_transforms
.iter()
.filter(|translation: &&LayerTranslation| {
self.widget_is_ancestor_of(translation.widget_id, candidate.widget_id)
})
.fold(Vector::ZERO, |current, translation| {
current + translation.delta
});
let residual = candidate.delta - inherited_delta;
if residual == Vector::ZERO {
continue;
}
minimized_transforms.push(LayerTranslation {
widget_id: candidate.widget_id,
delta: residual,
});
}
GraphChangeSet {
output_widgets,
repaint_widgets: minimized_repaint,
transform_widgets: minimized_transforms,
}
}
fn select_composition_only_transforms(
&self,
previous_scene: Option<&Scene>,
transform_widgets: &[LayerTranslation],
) -> Vec<LayerTranslation> {
let previous_layers = previous_scene.map(collect_scene_layers).unwrap_or_default();
transform_widgets
.iter()
.copied()
.filter(|translation| previous_layers.contains_key(&translation.widget_id))
.collect()
}
fn select_explicit_transform_translations(
&self,
previous_scene: Option<&Scene>,
invalidations: &[InvalidationRequest],
) -> Vec<LayerTranslation> {
let previous_layers = previous_scene.map(collect_scene_layers).unwrap_or_default();
let mut translations = Vec::new();
for request in invalidations {
if request.kind != InvalidationKind::Transform {
continue;
}
let InvalidationTarget::Widget(widget_id) = request.target else {
continue;
};
let resolved_boundary = self
.graph
.nearest_paint_boundary_ancestor_or_root(widget_id);
if resolved_boundary == self.root.id() {
continue;
}
let Some(previous) = previous_layers.get(&resolved_boundary) else {
continue;
};
let Some(current) = self.graph.node(resolved_boundary) else {
continue;
};
let delta = current.geometry.layout_bounds.origin - previous.bounds.origin;
if delta == Vector::ZERO {
continue;
}
if translations
.iter()
.all(|translation: &LayerTranslation| translation.widget_id != resolved_boundary)
{
translations.push(LayerTranslation {
widget_id: resolved_boundary,
delta,
});
}
}
translations
}
fn collect_explicit_layer_descriptor_refreshes(
&mut self,
previous_scene: Option<&Scene>,
invalidations: &[InvalidationRequest],
) -> Vec<LayerDescriptorRefresh> {
let Some(previous_scene) = previous_scene else {
return Vec::new();
};
if !invalidations.iter().any(|request| {
matches!(
request.kind,
InvalidationKind::Transform | InvalidationKind::Effect
)
}) {
return Vec::new();
}
let previous_layers = collect_scene_layers(previous_scene);
let mut refreshes = Vec::new();
let frame_time = self.frame_time();
for (widget_id, previous_descriptor) in previous_layers {
let Some(layer_scene) = previous_scene.layer_scene(widget_id).cloned() else {
continue;
};
let Some(descriptor) =
self.root
.layer_descriptor_for(widget_id, &layer_scene, frame_time)
else {
continue;
};
if descriptor.properties == previous_descriptor.properties {
continue;
}
refreshes.push(LayerDescriptorRefresh {
widget_id,
descriptor,
});
}
refreshes
}
fn widget_depth(&self, widget_id: WidgetId) -> usize {
self.graph.depth(widget_id).unwrap_or(usize::MAX)
}
fn minimize_layer_roots(&self, candidates: &mut Vec<WidgetId>) {
candidates.sort_by_key(|widget_id| (self.widget_depth(*widget_id), widget_id.get()));
candidates.dedup();
let mut minimized = Vec::with_capacity(candidates.len());
for widget_id in candidates.iter().copied() {
if minimized
.iter()
.any(|ancestor| self.widget_is_ancestor_of(*ancestor, widget_id))
{
continue;
}
minimized.push(widget_id);
}
*candidates = minimized;
}
fn default_dirty_region_for_request(
&self,
viewport_rect: Rect,
request: &InvalidationRequest,
) -> Rect {
match request.target {
InvalidationTarget::Widget(widget_id) => self
.graph
.node(widget_id)
.map(|node| node.geometry.paint_bounds)
.unwrap_or(viewport_rect),
InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => viewport_rect,
}
}
fn collect_layer_updates(
&self,
previous_scene: Option<&Scene>,
scene: &Scene,
invalidations: &[InvalidationRequest],
dirty_layers: &[WidgetId],
graph_dirty_widgets: &[WidgetId],
) -> Vec<SceneLayerUpdate> {
let current_layers = collect_scene_layers(scene);
if current_layers.is_empty() {
return Vec::new();
}
let previous_layers = previous_scene.map(collect_scene_layers).unwrap_or_default();
let mut updates = HashMap::<WidgetId, SceneLayerUpdateKind>::new();
let mut damage_regions = HashMap::<WidgetId, Rect>::new();
let explicit_transform_widgets = invalidations
.iter()
.filter_map(|request| {
if request.kind != InvalidationKind::Transform {
return None;
}
match request.target {
InvalidationTarget::Widget(widget_id) if self.graph.contains(widget_id) => {
Some(
self.graph
.nearest_paint_boundary_ancestor_or_root(widget_id),
)
}
_ => None,
}
})
.collect::<HashSet<_>>();
for request in invalidations {
let Some(kind) = invalidation_to_layer_update_kind(request.kind) else {
continue;
};
let widget_id = match request.target {
InvalidationTarget::Widget(widget_id) if self.graph.contains(widget_id) => self
.graph
.nearest_paint_boundary_ancestor_or_root(widget_id),
InvalidationTarget::Widget(_) => self.root.id(),
InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => self.root.id(),
};
if request.kind == InvalidationKind::Arrange
&& explicit_transform_widgets
.iter()
.any(|candidate| self.widget_is_ancestor_of(widget_id, *candidate))
{
continue;
}
merge_layer_update_kind(&mut updates, widget_id, kind);
if let Some(region) = request.region {
damage_regions
.entry(widget_id)
.and_modify(|current| *current = current.union(region))
.or_insert(region);
}
}
for (widget_id, descriptor) in ¤t_layers {
let Some(previous) = previous_layers.get(widget_id) else {
merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Content);
continue;
};
if descriptor.stack_host != previous.stack_host
|| descriptor.stack_order != previous.stack_order
|| descriptor.transient_owner_surface != previous.transient_owner_surface
|| descriptor.is_stack_surface != previous.is_stack_surface
{
merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Ordering);
}
if descriptor.properties.translation != previous.properties.translation
|| descriptor.properties.scale != previous.properties.scale
|| descriptor.properties.scale_anchor != previous.properties.scale_anchor
{
merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Transform);
}
if descriptor.properties.opacity != previous.properties.opacity {
merge_layer_update_kind(&mut updates, *widget_id, SceneLayerUpdateKind::Effect);
}
}
for widget_id in graph_dirty_widgets.iter().copied() {
merge_layer_update_kind(&mut updates, widget_id, SceneLayerUpdateKind::Transform);
}
for widget_id in dirty_layers.iter().copied() {
merge_layer_update_kind(&mut updates, widget_id, SceneLayerUpdateKind::Content);
}
let mut resolved_updates = Vec::new();
for (widget_id, kind) in updates {
let Some(descriptor) = current_layers.get(&widget_id).cloned() else {
continue;
};
let fallback_damage = previous_layers
.get(&widget_id)
.map(|previous| {
previous
.presented_paint_bounds()
.union(descriptor.presented_paint_bounds())
})
.unwrap_or(descriptor.presented_paint_bounds());
let damage = damage_regions
.get(&widget_id)
.copied()
.unwrap_or(fallback_damage);
resolved_updates
.push(SceneLayerUpdate::from_descriptor(kind, descriptor).with_damage(damage));
}
resolved_updates.sort_by_key(|update| update.owner.get());
resolved_updates
}
fn widget_is_ancestor_of(&self, ancestor: WidgetId, widget_id: WidgetId) -> bool {
self.graph.is_ancestor_of(ancestor, widget_id)
}
fn build_measure_scope(&self, invalidations: &[InvalidationRequest]) -> Rc<MeasureScope> {
let mut subtree_roots: HashSet<WidgetId> = HashSet::new();
let mut force_all = false;
for request in invalidations {
if !matches!(
request.kind,
InvalidationKind::Measure
| InvalidationKind::Text
| InvalidationKind::Visibility
| InvalidationKind::Ordering
) {
continue;
}
match request.target {
InvalidationTarget::Widget(widget_id) => {
subtree_roots.insert(widget_id);
}
InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => {
force_all = true;
}
}
}
if force_all || subtree_roots.is_empty() {
return Rc::new(MeasureScope::force_all());
}
let mut dirty: HashSet<WidgetId> = HashSet::new();
for widget_id in &subtree_roots {
if !self.graph.extend_ancestors(*widget_id, &mut dirty) {
return Rc::new(MeasureScope::force_all());
}
}
Rc::new(MeasureScope::scoped(dirty, subtree_roots))
}
fn build_arrange_scope(&self, invalidations: &[InvalidationRequest]) -> Rc<ArrangeScope> {
let mut subtree_roots: HashSet<WidgetId> = HashSet::new();
let mut force_all = false;
for request in invalidations {
if !matches!(
request.kind,
InvalidationKind::Measure
| InvalidationKind::Arrange
| InvalidationKind::Transform
| InvalidationKind::Clip
| InvalidationKind::Visibility
| InvalidationKind::Text
) {
continue;
}
match request.target {
InvalidationTarget::Widget(widget_id) => {
subtree_roots.insert(widget_id);
}
InvalidationTarget::Window(_) | InvalidationTarget::Surface(_) => {
force_all = true;
}
}
}
if force_all || subtree_roots.is_empty() {
return Rc::new(ArrangeScope::force_all());
}
let mut dirty: HashSet<WidgetId> = HashSet::new();
for widget_id in subtree_roots {
if !self.graph.extend_ancestors(widget_id, &mut dirty) {
return Rc::new(ArrangeScope::force_all());
}
}
Rc::new(ArrangeScope::scoped(dirty))
}
fn run_measure_arrange_pass(
&mut self,
invalidations: &[InvalidationRequest],
text_system: Arc<TextSystem>,
font_registry: Arc<FontRegistry>,
image_registry: Arc<ImageRegistry>,
) -> Vec<InvalidationRequest> {
let constraints = self.measure_constraints();
let scope = self.build_measure_scope(invalidations);
if (self.schedule.measure || self.viewport.is_none()) && scope.is_full_invalidation() {
self.measure_queries.borrow_mut().invalidate_context();
}
let mut measure_ctx = MeasureCtx::new_scoped_at(
self.id,
self.root.id(),
self.root.bounds(),
self.current_dpi_info(),
text_system,
font_registry,
image_registry,
scope,
self.frame_time(),
);
measure_ctx.set_query_cache(self.measure_queries.clone());
layout_work::record(|work| work.layout_passes += 1);
let measure_started = layout_work::started();
let measured_root = if self.schedule.measure || self.viewport.is_none() {
self.root.measure(&mut measure_ctx, constraints)
} else {
self.root.measured_size()
};
layout_work::elapsed(measure_started, |work, us| work.measure_us += us);
let viewport = constraints.clamp(measured_root);
let mut pass_invalidations = measure_ctx.take_invalidations();
let mut arrange_invalidations = invalidations.to_vec();
arrange_invalidations.extend(pass_invalidations.iter().cloned());
let arrange_scope = self.build_arrange_scope(&arrange_invalidations);
let mut arrange_ctx = ArrangeCtx::new_scoped_at(
self.id,
self.root.id(),
self.current_dpi_info(),
self.frame_time(),
arrange_scope,
);
let arrange_started = layout_work::started();
self.root.arrange(
&mut arrange_ctx,
Rect::from_origin_size(Point::ZERO, viewport),
);
layout_work::elapsed(arrange_started, |work, us| work.arrange_us += us);
self.viewport = Some(viewport);
self.schedule.measure = false;
self.schedule.arrange = false;
self.schedule.hit_test = false;
self.refresh_graph();
let mut invalidations = std::mem::take(&mut pass_invalidations);
self.apply_wake_requests(measure_ctx.take_wake_requests());
invalidations.extend(arrange_ctx.take_invalidations());
self.apply_wake_requests(arrange_ctx.take_wake_requests());
invalidations
}
fn refresh_graph(&mut self) {
let graph_started = layout_work::started();
if !self.previous_graph_saved && !self.graph.is_empty() {
std::mem::swap(&mut self.graph, &mut self.previous_graph);
self.previous_graph_saved = true;
}
self.graph.rebuild_in_place(
&self.root,
self.focus.focused_widget,
&self.last_paint_bounds_by_widget,
);
let overlay_focus = self.overlay_manager.sync(
self.graph.overlay_snapshots(),
&self.graph,
self.focus.focused_widget,
);
if overlay_focus.is_some() {
self.pending_overlay_focus = overlay_focus;
}
self.prune_runtime_state();
self.schedule.hit_test = false;
layout_work::elapsed(graph_started, |work, us| work.graph_us += us);
}
fn filter_modal_semantics(&self, mut nodes: Vec<SemanticsNode>) -> Vec<SemanticsNode> {
let Some(modal) = self.overlay_manager.active_modal() else {
return nodes;
};
let modal_subtree = self
.graph
.subtree_ids(modal)
.into_iter()
.collect::<HashSet<_>>();
let mut allowed = modal_subtree.clone();
let mut ancestor = self.graph.node(modal).and_then(|node| node.parent);
while let Some(widget_id) = ancestor {
allowed.insert(widget_id);
ancestor = self.graph.node(widget_id).and_then(|node| node.parent);
}
let parents = nodes
.iter()
.map(|node| (node.id, node.parent))
.collect::<HashMap<_, _>>();
let belongs_to_modal = |node: &SemanticsNode| {
if allowed.contains(&node.id) {
return true;
}
let mut current = node.parent;
let mut visited = HashSet::new();
while let Some(parent) = current {
if !visited.insert(parent) {
break;
}
if modal_subtree.contains(&parent) {
return true;
}
current = parents.get(&parent).copied().flatten();
}
false
};
nodes.retain(belongs_to_modal);
if let Some(node) = nodes.iter_mut().find(|node| node.id == modal) {
node.state.modal = true;
}
nodes
}
fn sync_scene_stack_metadata(&self, scene: &mut Scene) {
if self.scene_stack_metadata_is_current(scene) {
return;
}
scene.visit_layers_mut(&mut |layer| {
if let Some(node) = self.graph.node(layer.widget_id()) {
layer.descriptor.stack_host = node.stack_host;
layer.descriptor.stack_order = node.stack_surface_order;
layer.descriptor.transient_owner_surface = node.transient_owner_surface;
layer.descriptor.is_stack_surface = node.is_stack_surface;
layer.descriptor.hit_test = node.hit_test;
}
});
scene.reorder_stack_surfaces();
}
fn scene_stack_metadata_is_current(&self, scene: &Scene) -> bool {
let mut last_stack_order = None;
for command in scene.commands() {
let SceneCommand::Layer(layer) = command else {
continue;
};
if let Some(node) = self.graph.node(layer.widget_id()) {
let descriptor = &layer.descriptor;
if descriptor.stack_host != node.stack_host
|| descriptor.stack_order != node.stack_surface_order
|| descriptor.transient_owner_surface != node.transient_owner_surface
|| descriptor.is_stack_surface != node.is_stack_surface
|| descriptor.hit_test != node.hit_test
{
return false;
}
}
if layer.descriptor.is_stack_surface {
let order = layer.descriptor.stack_order;
if last_stack_order.is_some_and(|last| order < last) {
return false;
}
last_stack_order = Some(order);
}
if !self.scene_stack_metadata_is_current(&layer.scene) {
return false;
}
}
true
}
fn prune_runtime_state(&mut self) {
self.pointer_capture
.retain(|_, widget_id| self.graph.is_live(*widget_id));
let stale_grab_owner = self
.cursor
.grab_owner
.is_some_and(|widget_id| !self.graph.is_live(widget_id));
let stale_visibility_owner = self
.cursor
.visibility_owner
.is_some_and(|widget_id| !self.graph.is_live(widget_id));
if stale_grab_owner || stale_visibility_owner {
self.reset_cursor_state();
}
if self
.active_drag
.as_ref()
.is_some_and(|drag| !self.graph.is_live(drag.source))
{
self.active_drag = None;
}
self.scheduled_timers
.retain(|timer| self.graph.contains(timer.target));
self.delivering_timers
.retain(|_, widget_id| self.graph.contains(*widget_id));
self.async_wake_targets
.retain(|_, widget_id| self.graph.contains(*widget_id));
self.pending_async_wakeups
.retain(|token| self.async_wake_targets.contains_key(token));
self.requested_animation_frames
.retain(|widget_id| self.graph.contains(*widget_id));
self.delivering_animation_frames
.retain(|widget_id| self.graph.contains(*widget_id));
self.active_motions
.retain(|(widget_id, _), _| self.graph.contains(*widget_id));
self.motion_ends
.retain(|(widget_id, _), _| self.graph.contains(*widget_id));
if self.delivering_animation_frames.is_empty() && !self.wants_animation_frame() {
self.last_animation_frame_time = None;
}
if self
.focus
.focused_widget
.is_some_and(|widget_id| !self.graph.is_live(widget_id))
{
self.focus.focused_widget = None;
self.focused_semantics = None;
}
}
fn measure_constraints(&self) -> Constraints {
self.viewport_hint
.map(Constraints::tight)
.unwrap_or(Constraints::UNBOUNDED)
}
fn dpi_info_for_viewport(&self, viewport: Size) -> DpiInfo {
DpiInfo::new(
self.scale_factor,
self.raw_dpi,
viewport,
scale_viewport_to_surface_size(viewport, self.scale_factor),
)
.with_safe_area(self.safe_area)
}
fn current_dpi_info(&self) -> DpiInfo {
let viewport = self.viewport_hint.or(self.viewport).unwrap_or(Size::ZERO);
self.dpi_info_for_viewport(viewport)
}
fn clear_inspector_history(&mut self) {
self.event_route_history.clear();
self.reactive_invalidation_history.clear();
self.command_dispatch_history.clear();
self.invalidation_history.clear();
self.widget_rebuild_history.clear();
}
fn capture_inspector_diagnostics(&mut self, diagnostics: &RenderDiagnostics) {
if !self.inspector_tracing_enabled {
return;
}
extend_inspector_history(
&mut self.reactive_invalidation_history,
diagnostics.reactive_invalidations.iter().cloned(),
);
extend_inspector_history(
&mut self.command_dispatch_history,
diagnostics.command_dispatches.iter().cloned(),
);
extend_inspector_history(
&mut self.invalidation_history,
diagnostics.invalidations.iter().cloned(),
);
extend_inspector_history(
&mut self.widget_rebuild_history,
diagnostics.widget_rebuilds.iter().cloned(),
);
self.last_render_diagnostics = diagnostics.clone();
}
fn scheduler_snapshot(&self) -> SchedulerInspectorSnapshot {
let mut timers = self
.scheduled_timers
.iter()
.map(|timer| TimerInspectorSnapshot {
token: timer.token,
target: timer.target,
deadline: timer.deadline,
delivering: self.delivering_timers.contains_key(&timer.token),
})
.collect::<Vec<_>>();
for (&token, &target) in &self.delivering_timers {
if timers.iter().all(|timer| timer.token != token) {
timers.push(TimerInspectorSnapshot {
token,
target,
deadline: self.last_tick_time,
delivering: true,
});
}
}
timers.sort_by(|left, right| left.deadline.total_cmp(&right.deadline));
let mut async_tasks = self
.async_wake_targets
.iter()
.map(|(&token, &target)| AsyncTaskInspectorSnapshot {
token,
target,
pending_wake: self.pending_async_wakeups.contains(&token),
})
.collect::<Vec<_>>();
async_tasks.sort_by_key(|task| task.token.get());
SchedulerInspectorSnapshot {
timers,
async_tasks,
requested_animation_frames: self.requested_animation_frames.iter().copied().collect(),
delivering_animation_frames: self.delivering_animation_frames.iter().copied().collect(),
last_animation_frame_time: self.last_animation_frame_time,
}
}
fn inspector_snapshot(&self) -> WindowInspectorSnapshot {
let mut widget_diagnostics = Vec::new();
self.root.collect_diagnostics(&mut widget_diagnostics);
WindowInspectorSnapshot {
window_id: self.id,
title: self.title.clone(),
tracing_enabled: self.inspector_tracing_enabled,
focus_state: self.focus,
schedule: self.schedule,
semantics: self.last_semantics.clone(),
widget_graph: self.graph.snapshot(),
overlays: self.overlay_manager.snapshot(),
scheduler: self.scheduler_snapshot(),
widget_diagnostics,
last_render_diagnostics: self.last_render_diagnostics.clone(),
history: InspectorHistorySnapshot {
event_routes: self.event_route_history.iter().cloned().collect(),
reactive_invalidations: self
.reactive_invalidation_history
.iter()
.cloned()
.collect(),
command_dispatches: self.command_dispatch_history.iter().cloned().collect(),
invalidations: self.invalidation_history.iter().cloned().collect(),
widget_rebuilds: self.widget_rebuild_history.iter().cloned().collect(),
},
scene: self.last_frame.as_ref().map(|frame| {
SceneStatistics::from_frame_with_mode(
frame,
self.graph.nodes.len(),
window_scene_statistics_detail_mode(self.id),
)
}),
}
}
}
impl Drop for WindowState {
fn drop(&mut self) {
self.output_cache.borrow_mut().close();
reactive::unregister_window(self.id);
diagnostics::clear_widget_rebuilds(self.id);
}
}
fn normalize_scale_factor(scale_factor: f32) -> f32 {
if scale_factor.is_finite() && scale_factor > 0.0 {
scale_factor
} else {
1.0
}
}
fn scale_viewport_to_surface_size(viewport: Size, scale_factor: f32) -> Size {
if viewport.is_empty() {
return Size::ZERO;
}
let scale_factor = normalize_scale_factor(scale_factor);
Size::new(
(viewport.width * scale_factor).round().max(1.0),
(viewport.height * scale_factor).round().max(1.0),
)
}
impl WindowState {
fn assemble_semantics_tree(&mut self, nodes: Vec<SemanticsNode>) -> Vec<SemanticsNode> {
let semantic_ids: FxHashSet<_> = nodes.iter().map(|node| node.id).collect();
if self
.focused_semantics
.is_some_and(|focused| !semantic_ids.contains(&focused))
{
self.focused_semantics = self.focus.focused_widget;
}
nodes
.into_iter()
.map(|mut node| {
node.parent = self.resolve_semantics_parent(&semantic_ids, node.id, node.parent);
node.state.focused |= Some(node.id) == self.focused_semantics;
node
})
.collect()
}
fn resolve_semantics_parent(
&self,
semantic_ids: &FxHashSet<WidgetId>,
widget_id: WidgetId,
explicit_parent: Option<WidgetId>,
) -> Option<WidgetId> {
if let Some(parent) =
explicit_parent.filter(|parent| *parent != widget_id && semantic_ids.contains(parent))
{
return Some(parent);
}
let mut current = self.graph.node(widget_id).and_then(|node| node.parent);
while let Some(candidate) = current {
if semantic_ids.contains(&candidate) {
return Some(candidate);
}
current = self.graph.node(candidate).and_then(|node| node.parent);
}
None
}
}
#[derive(Default)]
struct WidgetGraph {
root: WidgetId,
nodes: FxHashMap<WidgetId, WidgetNodeSnapshot>,
order: Vec<WidgetId>,
host_surface_order: FxHashMap<WidgetId, Vec<WidgetId>>,
host_order_policy: FxHashMap<WidgetId, StackOrderPolicy>,
overlay_options: FxHashMap<WidgetId, OverlayOptions>,
overlay_parents: FxHashMap<WidgetId, Option<WidgetId>>,
overlay_surfaces: FxHashMap<WidgetId, Vec<WidgetId>>,
child_buffers: Vec<Vec<WidgetId>>,
}
#[derive(Clone, Copy)]
struct GraphCollectContext {
stack_host: WidgetId,
stack_surface: WidgetId,
overlay_owner: Option<WidgetId>,
inert: bool,
}
impl WidgetGraph {
fn empty(root: WidgetId) -> Self {
Self {
root,
nodes: FxHashMap::default(),
order: Vec::new(),
host_surface_order: FxHashMap::default(),
host_order_policy: FxHashMap::default(),
overlay_options: FxHashMap::default(),
overlay_parents: FxHashMap::default(),
overlay_surfaces: FxHashMap::default(),
child_buffers: Vec::new(),
}
}
fn rebuild_in_place(
&mut self,
root: &WidgetPod,
focused_widget: Option<WidgetId>,
paint_bounds_by_widget: &HashMap<WidgetId, Rect>,
) {
self.root = root.id();
for (_, mut node) in self.nodes.drain() {
node.children.clear();
self.child_buffers.push(node.children);
}
self.order.clear();
self.host_surface_order.clear();
self.host_order_policy.clear();
self.overlay_options.clear();
self.overlay_parents.clear();
self.overlay_surfaces.clear();
let mut inverse_cache = FxHashMap::default();
self.collect(
root,
None,
focused_widget,
paint_bounds_by_widget,
GraphCollectContext {
stack_host: root.id(),
stack_surface: root.id(),
overlay_owner: None,
inert: false,
},
&mut inverse_cache,
);
self.recompute_stack_surface_order();
}
fn recompute_stack_surface_order(&mut self) {
let mut position_by_surface = HashMap::<(WidgetId, WidgetId), usize>::new();
for (host, surfaces) in &self.host_surface_order {
for (index, surface) in surfaces.iter().copied().enumerate() {
position_by_surface.insert((*host, surface), index);
}
}
for node in self.nodes.values_mut() {
if let Some(order) = position_by_surface.get(&(node.stack_host, node.stack_surface)) {
node.stack_surface_order = *order;
}
}
}
fn update_paint_bounds_from_snapshot(
&mut self,
paint_bounds_by_widget: &HashMap<WidgetId, Rect>,
) {
for node in self.nodes.values_mut() {
node.geometry.paint_bounds = paint_bounds_by_widget
.get(&node.id)
.copied()
.unwrap_or(node.geometry.layout_bounds);
}
}
fn set_focused_widget(&mut self, focused_widget: Option<WidgetId>) {
for node in self.nodes.values_mut() {
node.focused = Some(node.id) == focused_widget;
}
}
fn is_empty(&self) -> bool {
self.nodes.is_empty()
}
fn contains(&self, widget_id: WidgetId) -> bool {
self.nodes.contains_key(&widget_id)
}
fn is_live(&self, widget_id: WidgetId) -> bool {
self.nodes.get(&widget_id).is_some_and(|node| !node.inert)
}
fn node(&self, widget_id: WidgetId) -> Option<&WidgetNodeSnapshot> {
self.nodes.get(&widget_id)
}
fn snapshot(&self) -> WidgetGraphSnapshot {
let mut stack_hosts = self
.host_order_policy
.iter()
.map(|(host, order_policy)| StackHostSnapshot {
host: *host,
order_policy: *order_policy,
surfaces: self
.host_surface_order
.get(host)
.cloned()
.unwrap_or_default(),
})
.collect::<Vec<_>>();
stack_hosts.sort_by_key(|host| host.host.get());
WidgetGraphSnapshot {
root: self.root,
nodes: self
.order
.iter()
.filter_map(|widget_id| self.nodes.get(widget_id).cloned())
.collect(),
stack_hosts,
}
}
fn hit_test(&self, point: Point) -> Option<WidgetId> {
self.hit_test_node(self.root, point)
}
fn hit_test_within(&self, widget_id: WidgetId, point: Point) -> Option<WidgetId> {
self.hit_test_node(widget_id, point)
}
fn path_to(&self, target: WidgetId) -> Option<Vec<WidgetId>> {
let mut path = Vec::new();
let mut current = Some(target);
while let Some(widget_id) = current {
let node = self.node(widget_id)?;
path.push(widget_id);
current = node.parent;
}
path.reverse();
Some(path)
}
fn depth(&self, target: WidgetId) -> Option<usize> {
let mut depth = 0usize;
let mut current = Some(target);
while let Some(widget_id) = current {
let node = self.node(widget_id)?;
depth += 1;
current = node.parent;
}
Some(depth)
}
fn is_ancestor_of(&self, ancestor: WidgetId, target: WidgetId) -> bool {
let mut current = self.node(target).and_then(|node| node.parent);
while let Some(widget_id) = current {
if widget_id == ancestor {
return true;
}
current = self.node(widget_id).and_then(|node| node.parent);
}
false
}
fn extend_ancestors(&self, target: WidgetId, ancestors: &mut HashSet<WidgetId>) -> bool {
let mut current = Some(target);
while let Some(widget_id) = current {
let Some(node) = self.node(widget_id) else {
return false;
};
ancestors.insert(widget_id);
current = node.parent;
}
true
}
fn subtree_ids(&self, root: WidgetId) -> Vec<WidgetId> {
let mut subtree = Vec::new();
let mut pending = vec![root];
while let Some(widget_id) = pending.pop() {
let Some(node) = self.node(widget_id) else {
continue;
};
subtree.push(widget_id);
pending.extend(node.children.iter().copied());
}
subtree
}
fn nearest_paint_boundary_ancestor_or_root(&self, widget_id: WidgetId) -> WidgetId {
let mut current = Some(widget_id);
while let Some(candidate) = current {
let Some(node) = self.node(candidate) else {
break;
};
if node.paint_boundary == PaintBoundaryMode::Explicit {
return candidate;
}
current = node.parent;
}
self.root
}
fn next_focusable(&self, current: Option<WidgetId>, backwards: bool) -> Option<WidgetId> {
let focusable: Vec<_> = self
.order
.iter()
.copied()
.filter(|widget_id| self.node(*widget_id).is_some_and(|node| node.accepts_focus))
.collect();
if focusable.is_empty() {
return None;
}
let fallback = if backwards {
focusable.last().copied()
} else {
focusable.first().copied()
};
let Some(current) = current else {
return fallback;
};
let Some(index) = focusable.iter().position(|widget_id| *widget_id == current) else {
return fallback;
};
if backwards {
Some(focusable[(index + focusable.len() - 1) % focusable.len()])
} else {
Some(focusable[(index + 1) % focusable.len()])
}
}
fn first_focusable_within(
&self,
overlay_owner: WidgetId,
include_owner: bool,
) -> Option<WidgetId> {
self.order.iter().copied().find(|candidate| {
self.node(*candidate).is_some_and(|node| node.accepts_focus)
&& (include_owner && *candidate == overlay_owner
|| self.is_ancestor_of(overlay_owner, *candidate))
})
}
fn next_focusable_within(
&self,
scope: WidgetId,
current: Option<WidgetId>,
backwards: bool,
) -> Option<WidgetId> {
let focusable = self
.order
.iter()
.copied()
.filter(|candidate| {
self.node(*candidate).is_some_and(|node| node.accepts_focus)
&& (*candidate == scope || self.is_ancestor_of(scope, *candidate))
})
.collect::<Vec<_>>();
if focusable.is_empty() {
return None;
}
let fallback = if backwards {
focusable.last().copied()
} else {
focusable.first().copied()
};
let Some(current) = current else {
return fallback;
};
let Some(index) = focusable.iter().position(|candidate| *candidate == current) else {
return fallback;
};
if backwards {
Some(focusable[(index + focusable.len() - 1) % focusable.len()])
} else {
Some(focusable[(index + 1) % focusable.len()])
}
}
fn overlay_snapshots(&self) -> Vec<OverlaySnapshot> {
self.order
.iter()
.copied()
.filter_map(|owner| {
let options = self.overlay_options.get(&owner).copied()?;
Some(OverlaySnapshot {
owner,
parent: self.overlay_parents.get(&owner).copied().flatten(),
surfaces: self
.overlay_surfaces
.get(&owner)
.cloned()
.unwrap_or_default(),
options,
order: 0,
})
})
.enumerate()
.map(|(order, mut snapshot)| {
snapshot.order = order;
snapshot
})
.collect()
}
fn collect(
&mut self,
pod: &WidgetPod,
parent: Option<WidgetId>,
focused_widget: Option<WidgetId>,
paint_bounds_by_widget: &HashMap<WidgetId, Rect>,
context: GraphCollectContext,
inverse_cache: &mut FxHashMap<[u32; 6], Option<Transform>>,
) {
let id = pod.id();
self.order.push(id);
let inert = context.inert || pod.is_inert();
let overlay_options = pod.current_overlay_options();
let is_overlay_owner = overlay_options.is_some();
let overlay_owner = if is_overlay_owner {
Some(id)
} else {
context.overlay_owner
};
if let Some(options) = overlay_options {
self.overlay_options.insert(id, options);
self.overlay_parents.insert(id, context.overlay_owner);
}
let host_options = if id == self.root {
Some(pod.current_stack_host_options().unwrap_or_default())
} else {
pod.current_stack_host_options()
};
let is_stack_host = host_options.is_some();
let resolved_host = if is_stack_host {
id
} else {
context.stack_host
};
let host_policy = host_options
.map(|options| options.order_policy)
.unwrap_or(StackOrderPolicy::Stable);
if is_stack_host {
self.host_order_policy.insert(resolved_host, host_policy);
} else {
self.host_order_policy
.entry(resolved_host)
.or_insert(StackOrderPolicy::Stable);
}
let resolved_policy = *self
.host_order_policy
.get(&resolved_host)
.unwrap_or(&StackOrderPolicy::Stable);
let surface_options = pod.current_stack_surface_options();
let emits_layer = pod.current_layer_options().emits_layer();
let is_direct_child_of_host = parent == Some(resolved_host);
let is_stack_surface = id != self.root
&& emits_layer
&& (surface_options.is_some() || is_direct_child_of_host);
let hit_test = !inert && surface_options.is_none_or(|options| options.hit_test);
let resolved_surface = if is_stack_surface {
id
} else {
context.stack_surface
};
let transient_owner_surface = surface_options
.filter(|options| emits_layer && options.transient && context.stack_surface != id)
.map(|_| context.stack_surface);
if is_stack_surface {
let surfaces = self.host_surface_order.entry(resolved_host).or_default();
if !surfaces.contains(&id) {
surfaces.push(id);
}
}
if is_stack_surface && let Some(owner) = overlay_owner {
self.overlay_surfaces.entry(owner).or_default().push(id);
}
let stack_surface_order = self
.host_surface_order
.get(&resolved_host)
.and_then(|surfaces| {
surfaces
.iter()
.position(|surface| *surface == resolved_surface)
})
.unwrap_or(0);
let children = {
let mut children = self.child_buffers.pop().unwrap_or_default();
children.clear();
let mut visitor = CollectChildrenVisitor {
graph: self,
parent: id,
focused_widget,
paint_bounds_by_widget,
context: GraphCollectContext {
stack_host: resolved_host,
stack_surface: resolved_surface,
overlay_owner,
inert,
},
children,
inverse_cache,
};
pod.visit_children(&mut visitor);
visitor.children
};
let local_bounds = pod.bounds();
let presentation_transform = pod.presentation_transform();
let inverse_presentation_transform = if presentation_transform.is_identity() {
Some(Transform::IDENTITY)
} else {
*inverse_cache
.entry(transform_bits(presentation_transform))
.or_insert_with(|| presentation_transform.inverse())
};
let layout_bounds = presentation_transform.transform_rect_bbox(local_bounds);
let input_bounds = layout_bounds;
let paint_bounds = paint_bounds_by_widget
.get(&id)
.copied()
.unwrap_or(layout_bounds);
self.nodes.insert(
id,
WidgetNodeSnapshot {
id,
widget_name: pod.debug_name(),
parent,
children,
measured_size: pod.measured_size(),
geometry: WidgetGeometrySnapshot::new(layout_bounds, input_bounds, paint_bounds),
local_bounds,
presentation_transform,
inverse_presentation_transform,
bounds: layout_bounds,
paint_boundary: pod.current_paint_boundary_mode(),
stack_host: resolved_host,
stack_surface: resolved_surface,
stack_surface_order,
transient_owner_surface,
overlay_owner,
is_overlay_owner,
is_stack_host,
is_stack_surface,
hit_test,
hit_test_self: pod.current_hit_test_self(),
stack_order_policy: resolved_policy,
accepts_focus: !inert && pod.accepts_focus(),
focused: Some(id) == focused_widget,
inert,
},
);
}
fn hit_test_node(&self, widget_id: WidgetId, point: Point) -> Option<WidgetId> {
let node = self.node(widget_id)?;
if !node.hit_test || !node.geometry.input_bounds.contains(point) {
return None;
}
let local_point = node.inverse_presentation_transform?.transform_point(point);
if !node.local_bounds.contains(local_point) {
return None;
}
if node.is_stack_host {
let mut tested_surfaces = HashSet::new();
if let Some(ordered_surfaces) = self.host_surface_order.get(&node.id) {
for surface_id in ordered_surfaces.iter().rev().copied() {
if surface_id == widget_id {
continue;
}
tested_surfaces.insert(surface_id);
if let Some(hit) = self.hit_test_node(surface_id, point) {
return Some(hit);
}
}
}
for child_id in node.children.iter().rev() {
if self.node(*child_id).is_some_and(|child| {
child.is_stack_surface || tested_surfaces.contains(child_id)
}) {
continue;
}
if let Some(hit) = self.hit_test_node(*child_id, point) {
return Some(hit);
}
}
return node.hit_test_self.then_some(widget_id);
}
for child_id in node.children.iter().rev() {
if let Some(hit) = self.hit_test_node(*child_id, point) {
return Some(hit);
}
}
node.hit_test_self.then_some(widget_id)
}
}
struct CollectChildrenVisitor<'a> {
graph: &'a mut WidgetGraph,
parent: WidgetId,
focused_widget: Option<WidgetId>,
paint_bounds_by_widget: &'a HashMap<WidgetId, Rect>,
context: GraphCollectContext,
children: Vec<WidgetId>,
inverse_cache: &'a mut FxHashMap<[u32; 6], Option<Transform>>,
}
impl WidgetPodVisitor for CollectChildrenVisitor<'_> {
fn visit(&mut self, child: &WidgetPod) {
self.children.push(child.id());
self.graph.collect(
child,
Some(self.parent),
self.focused_widget,
self.paint_bounds_by_widget,
self.context,
self.inverse_cache,
);
}
}
fn transform_bits(transform: Transform) -> [u32; 6] {
[
transform.xx.to_bits(),
transform.yx.to_bits(),
transform.xy.to_bits(),
transform.yy.to_bits(),
transform.dx.to_bits(),
transform.dy.to_bits(),
]
}
struct EventRouteResult {
path: Vec<WidgetId>,
effects: EventEffects,
focus_request: Option<FocusRequest>,
handled: bool,
}
#[derive(Default)]
struct HoverTransitionResult {
effects: EventEffects,
focus_request: Option<FocusRequest>,
skip_primary_route: bool,
}
#[derive(Default)]
struct EventEffects {
invalidations: Vec<InvalidationRequest>,
wake_requests: Vec<WakeRequest>,
pointer_capture_requests: Vec<PointerCaptureRequest>,
cursor_requests: Vec<CursorRequest>,
drag_requests: Vec<DragRequest>,
drop_acceptances: Vec<DropAcceptanceRequest>,
posted_events: Vec<widget::PostedEventRequest>,
posted_commands: Vec<widget::PostedCommandRequest>,
}
impl EventEffects {
fn extend(&mut self, dispatch: widget::EventDispatch) {
self.invalidations.extend(dispatch.invalidations);
self.wake_requests.extend(dispatch.wake_requests);
self.pointer_capture_requests
.extend(dispatch.pointer_capture_requests);
self.cursor_requests.extend(dispatch.cursor_requests);
self.drag_requests.extend(dispatch.drag_requests);
self.drop_acceptances.extend(dispatch.drop_acceptances);
self.posted_events.extend(dispatch.posted_events);
self.posted_commands.extend(dispatch.posted_commands);
}
fn merge(&mut self, effects: EventEffects) {
self.invalidations.extend(effects.invalidations);
self.wake_requests.extend(effects.wake_requests);
self.pointer_capture_requests
.extend(effects.pointer_capture_requests);
self.cursor_requests.extend(effects.cursor_requests);
self.drag_requests.extend(effects.drag_requests);
self.drop_acceptances.extend(effects.drop_acceptances);
self.posted_events.extend(effects.posted_events);
self.posted_commands.extend(effects.posted_commands);
}
}
fn empty_dispatch() -> widget::EventDispatch {
widget::EventDispatch {
handled: false,
invalidations: Vec::new(),
focus_request: None,
wake_requests: Vec::new(),
pointer_capture_requests: Vec::new(),
cursor_requests: Vec::new(),
drag_requests: Vec::new(),
drop_acceptances: Vec::new(),
posted_events: Vec::new(),
posted_commands: Vec::new(),
}
}
const MAX_PENDING_TRACE_SAMPLES: usize = 512;
const MAX_INSPECTOR_HISTORY_SAMPLES: usize = 256;
fn push_trace<T>(samples: &mut Vec<T>, sample: T) {
if samples.len() == MAX_PENDING_TRACE_SAMPLES {
samples.remove(0);
}
samples.push(sample);
}
fn extend_traces<T>(samples: &mut Vec<T>, additions: impl IntoIterator<Item = T>) {
for sample in additions {
push_trace(samples, sample);
}
}
fn push_inspector_history<T>(samples: &mut VecDeque<T>, sample: T) {
if samples.len() == MAX_INSPECTOR_HISTORY_SAMPLES {
samples.pop_front();
}
samples.push_back(sample);
}
fn extend_inspector_history<T>(samples: &mut VecDeque<T>, additions: impl IntoIterator<Item = T>) {
for sample in additions {
push_inspector_history(samples, sample);
}
}
fn command_sample(
command: &QueuedCommand,
handlers: Vec<String>,
handled: bool,
delivered: bool,
) -> CommandDispatchSample {
CommandDispatchSample {
sequence: command.sequence,
name: command.key.name.to_string(),
payload_type: command.key.payload_type_name.to_string(),
target: command.target,
delivery: command.delivery,
handlers,
handled,
delivered,
}
}
fn event_trace_source(event: &Event) -> String {
let kind = match event {
Event::Pointer(event) => format!("pointer:{:?}", event.kind),
Event::RawMouseMotion(_) => "raw-mouse-motion".to_string(),
Event::Drag(event) => format!("drag:{:?}", event.kind),
Event::Keyboard(_) => "keyboard".to_string(),
Event::Ime(_) => "ime".to_string(),
Event::Semantics(_) => "semantics".to_string(),
Event::Wake(event) => format!("wake:{event:?}"),
Event::Window(event) => format!("window:{event:?}"),
Event::Custom(event) => format!("custom:{}", event.kind),
};
format!("event:{kind}")
}
fn inspector_event_kind(event: &Event) -> &'static str {
match event {
Event::Pointer(_) => "pointer",
Event::RawMouseMotion(_) => "raw-mouse-motion",
Event::Drag(_) => "drag",
Event::Keyboard(_) => "keyboard",
Event::Ime(_) => "ime",
Event::Semantics(_) => "semantics",
Event::Wake(_) => "wake",
Event::Window(_) => "window",
Event::Custom(_) => "custom",
}
}
fn drag_key_modifiers(key: &KeyboardEvent) -> Modifiers {
let mut modifiers = key.modifiers;
let pressed = key.state == KeyState::Pressed;
match key.key.as_str() {
"Shift" => modifiers.shift = pressed,
"Control" => modifiers.control = pressed,
"Alt" | "AltGraph" => modifiers.alt = pressed,
"Meta" | "Super" => modifiers.meta = pressed,
_ => {}
}
modifiers
}
fn nearest_drop_acceptance(
acceptances: &[DropAcceptanceRequest],
path: &[WidgetId],
) -> Option<DropAcceptanceRequest> {
acceptances
.iter()
.filter_map(|acceptance| {
path.iter()
.position(|widget_id| *widget_id == acceptance.target)
.map(|index| (index, *acceptance))
})
.max_by_key(|(index, _)| *index)
.map(|(_, acceptance)| acceptance)
}
fn collect_dirty_regions<F>(
viewport: Size,
invalidations: &[InvalidationRequest],
repainted: bool,
default_region_for: F,
) -> Vec<DirtyRegion>
where
F: FnMut(&InvalidationRequest) -> Rect,
{
let viewport_rect = Rect::from_origin_size(Point::ZERO, viewport);
let mut default_region_for = default_region_for;
if invalidations.is_empty() {
return if repainted {
vec![DirtyRegion::new(viewport_rect, InvalidationKind::Paint)]
} else {
Vec::new()
};
}
let mut dirty_regions: Vec<_> = invalidations
.iter()
.map(|request| {
DirtyRegion::new(
request
.region
.unwrap_or_else(|| default_region_for(request)),
request.kind,
)
})
.collect();
if repainted
&& dirty_regions
.iter()
.all(|region| region.kind != InvalidationKind::Paint)
{
dirty_regions.push(DirtyRegion::new(viewport_rect, InvalidationKind::Paint));
}
dirty_regions
}
fn collect_scene_layers(scene: &Scene) -> HashMap<WidgetId, SceneLayerDescriptor> {
let mut layers = HashMap::new();
scene.visit_layers(&mut |layer| {
layers.insert(layer.widget_id(), layer.descriptor.clone());
});
layers
}
const TEXT_LAYOUT_PRUNE_SLACK: usize = 64;
fn retain_text_layouts_for_scene(text_system: &TextSystem, scene: &Scene) {
text_system.retain_persistent_layouts(&active_text_layout_handles(scene));
}
fn active_text_layout_handles(scene: &Scene) -> HashSet<TextLayoutHandle> {
let mut handles = HashSet::new();
scene.visit_commands(&mut |command| match command {
SceneCommand::DrawShapedText(text) => {
handles.insert(text.layout_handle);
}
SceneCommand::DrawShapedTextWindow(text) => {
handles.insert(text.layout_handle);
}
_ => {}
});
handles
}
fn same_layer_translation(boundary_delta: Vector, delta: Vector) -> bool {
const TOLERANCE: f32 = 1.0 / 64.0;
(boundary_delta.x - delta.x).abs() <= TOLERANCE
&& (boundary_delta.y - delta.y).abs() <= TOLERANCE
}
fn resolve_snapshot_paint_boundary_or_root(
nodes: &FxHashMap<WidgetId, WidgetNodeSnapshot>,
root: WidgetId,
widget_id: WidgetId,
) -> WidgetId {
let mut current = Some(widget_id);
while let Some(candidate) = current {
let Some(node) = nodes.get(&candidate) else {
break;
};
if node.paint_boundary == PaintBoundaryMode::Explicit {
return candidate;
}
current = node.parent;
}
root
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum HitTestCompositionPhase {
Normal,
Overlay,
Effect,
}
fn scene_hit_test_for_phase(
scene: &Scene,
point: Point,
target_phase: HitTestCompositionPhase,
inherited_phase: HitTestCompositionPhase,
) -> Option<WidgetId> {
for command in scene.commands().iter().rev() {
let SceneCommand::Layer(layer) = command else {
continue;
};
let layer_phase = next_hit_test_phase(inherited_phase, layer.descriptor.composition_mode);
if !layer.descriptor.paint_bounds.contains(point) {
continue;
}
if !layer.descriptor.hit_test {
continue;
}
if let Some(hit) = scene_hit_test_for_phase(&layer.scene, point, target_phase, layer_phase)
{
return Some(hit);
}
if layer_phase == target_phase {
return Some(layer.widget_id());
}
}
None
}
fn next_hit_test_phase(
inherited_phase: HitTestCompositionPhase,
composition_mode: LayerCompositionMode,
) -> HitTestCompositionPhase {
match (inherited_phase, composition_mode) {
(HitTestCompositionPhase::Effect, _) | (_, LayerCompositionMode::Effect) => {
HitTestCompositionPhase::Effect
}
(HitTestCompositionPhase::Overlay, _) | (_, LayerCompositionMode::Overlay) => {
HitTestCompositionPhase::Overlay
}
_ => HitTestCompositionPhase::Normal,
}
}
fn root_repaint_covers_graph_changes(
root: WidgetId,
invalidations: &[InvalidationRequest],
) -> bool {
let root_transform = invalidations.iter().any(|request| {
request.kind == InvalidationKind::Transform
&& request.target == InvalidationTarget::Widget(root)
});
let root_content = invalidations.iter().any(|request| {
matches!(
request.kind,
InvalidationKind::Measure
| InvalidationKind::Clip
| InvalidationKind::Visibility
| InvalidationKind::Paint
| InvalidationKind::Text
| InvalidationKind::Resources
) && request.target == InvalidationTarget::Widget(root)
});
root_transform && root_content
}
fn invalidation_to_layer_update_kind(kind: InvalidationKind) -> Option<SceneLayerUpdateKind> {
match kind {
InvalidationKind::Measure | InvalidationKind::Arrange | InvalidationKind::Transform => {
Some(SceneLayerUpdateKind::Transform)
}
InvalidationKind::Ordering => Some(SceneLayerUpdateKind::Ordering),
InvalidationKind::Clip => Some(SceneLayerUpdateKind::Clip),
InvalidationKind::Effect => Some(SceneLayerUpdateKind::Effect),
InvalidationKind::Visibility => Some(SceneLayerUpdateKind::Visibility),
InvalidationKind::Paint | InvalidationKind::Text => Some(SceneLayerUpdateKind::Content),
InvalidationKind::Resources => Some(SceneLayerUpdateKind::Resources),
InvalidationKind::HitTest | InvalidationKind::Semantics => None,
}
}
fn merge_layer_update_kind(
updates: &mut HashMap<WidgetId, SceneLayerUpdateKind>,
widget_id: WidgetId,
kind: SceneLayerUpdateKind,
) {
updates
.entry(widget_id)
.and_modify(|current| {
if layer_update_priority(kind) > layer_update_priority(*current) {
*current = kind;
}
})
.or_insert(kind);
}
fn layer_update_priority(kind: SceneLayerUpdateKind) -> u8 {
match kind {
SceneLayerUpdateKind::Visibility => 0,
SceneLayerUpdateKind::Ordering => 1,
SceneLayerUpdateKind::Transform => 2,
SceneLayerUpdateKind::Clip => 3,
SceneLayerUpdateKind::Content => 4,
SceneLayerUpdateKind::Effect => 5,
SceneLayerUpdateKind::Resources => 6,
}
}
#[derive(Debug, Clone, PartialEq)]
pub struct RenderOutput {
pub title: String,
pub frame: SceneFrame,
pub semantics: Vec<SemanticsNode>,
pub ime_composition_rect: Option<Rect>,
pub diagnostics: RenderDiagnostics,
}
#[cfg(test)]
mod tests;