#![forbid(unsafe_code)]
mod command;
mod diagnostics;
mod logo;
mod overlay;
mod reactive;
mod widget;
use std::{
collections::{BTreeSet, HashMap, HashSet, VecDeque},
sync::{
Arc,
atomic::{AtomicU64, Ordering},
},
};
use sui_core::{
AsyncWakeToken, Clipboard, ClipboardBackend, CustomEvent, DirtyRegion, DragEvent,
DragEventKind, DragOutcome, DragPayload, DragScopeId, DragSessionId, DropEffect, Error, Event,
FontHandle, ImageHandle, InvalidationKind, InvalidationRequest, InvalidationTarget, KeyState,
Point, PointerButton, PointerButtons, PointerEvent, PointerEventKind, Rect, Result,
SemanticsActionRequest, SemanticsEvent, SemanticsNode, Size, TimerToken, 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 command::{
Command, CommandController, CommandCtx, CommandDelivery, CommandKey, CommandSender,
CommandTarget,
};
use command::{CommandInvalidation, CommandListeners, QueuedCommand};
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,
};
pub use logo::{DEFAULT_SUI_LOGO_SVG, default_sui_logo_image};
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, SafeAreaInsets};
pub use sui_layout::LayoutContext;
use widget::MeasureScope;
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::{
BeginDragRequest, DragRequest, DropAcceptanceRequest, FocusRequest, PaintImageResource,
PointerCaptureRequest, WakeRequest,
};
pub const REACTIVE_CHANGED: CommandKey<()> = CommandKey::new("sui.reactive.changed");
type PaintOutput = (
Scene,
Vec<(ImageHandle, PaintImageResource)>,
HashMap<WidgetId, Rect>,
Vec<InvalidationRequest>,
Option<Rect>,
);
static NEXT_WINDOW_ID: AtomicU64 = AtomicU64::new(1);
pub struct WindowBuilder {
title: String,
icon: Option<WindowIcon>,
root: Option<WidgetPod>,
command_listeners: CommandListeners,
}
impl WindowBuilder {
pub fn new() -> Self {
Self {
title: "SUI Window".to_string(),
icon: Some(WindowIcon::sui()),
root: None,
command_listeners: CommandListeners::default(),
}
}
pub fn title(mut self, title: impl Into<String>) -> Self {
self.title = title.into();
self
}
pub fn icon(mut self, icon: WindowIcon) -> Self {
self.icon = Some(icon);
self
}
pub fn icon_svg(mut self, svg: impl Into<Vec<u8>>) -> Self {
self.icon = Some(WindowIcon::from_svg(svg));
self
}
pub fn without_icon(mut self) -> Self {
self.icon = None;
self
}
pub fn root<W>(mut self, root: W) -> Self
where
W: Widget + 'static,
{
self.root = Some(WidgetPod::new(root));
self
}
pub fn controller(mut self, controller: impl CommandController + 'static) -> Self {
self.command_listeners.push_controller(controller);
self
}
pub fn on_command<T, F>(mut self, key: CommandKey<T>, handler: F) -> Self
where
T: Send + Sync + 'static,
F: FnMut(&mut CommandCtx, &T) + 'static,
{
self.command_listeners.push_subscription(key, handler);
self
}
fn build(self, window_id: WindowId, command_sender: CommandSender) -> Result<WindowState> {
let root = self
.root
.ok_or_else(|| Error::new("window root widget must be set before building"))?;
Ok(WindowState::new(
window_id,
self.title,
self.icon,
root,
self.command_listeners,
command_sender,
))
}
}
impl Default for WindowBuilder {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum WindowIcon {
Svg {
data: Arc<[u8]>,
},
Rgba8 {
width: u32,
height: u32,
data: Arc<[u8]>,
},
}
impl WindowIcon {
pub fn sui() -> Self {
Self::from_svg(DEFAULT_SUI_LOGO_SVG)
}
pub fn from_svg(svg: impl Into<Vec<u8>>) -> Self {
Self::Svg {
data: Arc::from(svg.into()),
}
}
pub fn from_rgba8(width: u32, height: u32, data: impl Into<Vec<u8>>) -> Result<Self> {
if width == 0 || height == 0 {
return Err(Error::new("window icon dimensions must be non-zero"));
}
let data = data.into();
let expected_len = (width as usize)
.checked_mul(height as usize)
.and_then(|pixels| pixels.checked_mul(4))
.ok_or_else(|| Error::new("window icon dimensions overflow RGBA buffer length"))?;
if data.len() != expected_len {
return Err(Error::new(format!(
"window icon RGBA buffer length mismatch: expected {expected_len}, got {}",
data.len()
)));
}
Ok(Self::Rgba8 {
width,
height,
data: Arc::from(data),
})
}
pub fn as_svg(&self) -> Option<&[u8]> {
match self {
Self::Svg { data } => Some(data),
Self::Rgba8 { .. } => None,
}
}
pub fn as_rgba8(&self) -> Option<(u32, u32, &[u8])> {
match self {
Self::Svg { .. } => None,
Self::Rgba8 {
width,
height,
data,
} => Some((*width, *height, data)),
}
}
}
impl Default for WindowIcon {
fn default() -> Self {
Self::sui()
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct EmbeddedSvgImageResource {
handle: ImageHandle,
data: &'static [u8],
size: Option<(u32, u32)>,
}
impl EmbeddedSvgImageResource {
pub const fn new(handle: ImageHandle, data: &'static [u8]) -> Self {
Self {
handle,
data,
size: None,
}
}
pub const fn at_size(
handle: ImageHandle,
width: u32,
height: u32,
data: &'static [u8],
) -> Self {
Self {
handle,
data,
size: Some((width, height)),
}
}
pub const fn handle(self) -> ImageHandle {
self.handle
}
pub const fn data(self) -> &'static [u8] {
self.data
}
pub const fn size(self) -> Option<(u32, u32)> {
self.size
}
pub fn registered_image(self) -> Result<RegisteredImage> {
match self.size {
Some((width, height)) => RegisteredImage::from_svg_at_size(width, height, self.data),
None => RegisteredImage::from_svg(self.data),
}
}
}
pub struct Application {
windows: Vec<WindowBuilder>,
next_font_id: u64,
next_image_id: u64,
font_registry: Arc<FontRegistry>,
image_registry: Arc<ImageRegistry>,
command_listeners: CommandListeners,
}
impl Application {
pub fn new() -> Self {
Self::default()
}
pub fn window(mut self, window: WindowBuilder) -> Self {
self.windows.push(window);
self
}
pub fn controller(mut self, controller: impl CommandController + 'static) -> Self {
self.command_listeners.push_controller(controller);
self
}
pub fn on_command<T, F>(mut self, key: CommandKey<T>, handler: F) -> Self
where
T: Send + Sync + 'static,
F: FnMut(&mut CommandCtx, &T) + 'static,
{
self.command_listeners.push_subscription(key, handler);
self
}
pub fn register_font(&mut self, handle: FontHandle, font: RegisteredFont) -> Result<()> {
if Arc::make_mut(&mut self.font_registry)
.insert(handle, font)
.is_some()
{
return Err(Error::new(format!(
"font handle {} is already registered",
handle.get()
)));
}
self.next_font_id = self.next_font_id.max(handle.get() + 1);
Ok(())
}
pub fn register_font_bytes(&mut self, data: impl Into<Vec<u8>>) -> Result<FontHandle> {
let handle = FontHandle::new(self.next_font_id.max(1));
self.next_font_id = handle.get() + 1;
self.register_font(handle, RegisteredFont::from_bytes(data))?;
Ok(handle)
}
pub fn register_image(&mut self, handle: ImageHandle, image: RegisteredImage) -> Result<()> {
if Arc::make_mut(&mut self.image_registry)
.insert(handle, image)
.is_some()
{
return Err(Error::new(format!(
"image handle {} is already registered",
handle.get()
)));
}
self.next_image_id = self.next_image_id.max(handle.get() + 1);
Ok(())
}
pub fn register_svg_image_with_handle(
&mut self,
handle: ImageHandle,
data: impl AsRef<[u8]>,
) -> Result<()> {
self.register_image(handle, RegisteredImage::from_svg(data)?)
}
pub fn register_rgba_image(
&mut self,
width: u32,
height: u32,
data: impl Into<Vec<u8>>,
) -> Result<ImageHandle> {
let handle = ImageHandle::new(self.next_image_id.max(1));
self.next_image_id = handle.get() + 1;
self.register_image(handle, RegisteredImage::from_rgba8(width, height, data)?)?;
Ok(handle)
}
pub fn register_svg_image(&mut self, data: impl AsRef<[u8]>) -> Result<ImageHandle> {
let handle = ImageHandle::new(self.next_image_id.max(1));
self.next_image_id = handle.get() + 1;
self.register_image(handle, RegisteredImage::from_svg(data)?)?;
Ok(handle)
}
pub fn register_svg_image_at_size_with_handle(
&mut self,
handle: ImageHandle,
width: u32,
height: u32,
data: impl AsRef<[u8]>,
) -> Result<()> {
self.register_image(
handle,
RegisteredImage::from_svg_at_size(width, height, data)?,
)
}
pub fn register_svg_image_at_size(
&mut self,
width: u32,
height: u32,
data: impl AsRef<[u8]>,
) -> Result<ImageHandle> {
let handle = ImageHandle::new(self.next_image_id.max(1));
self.next_image_id = handle.get() + 1;
self.register_image(
handle,
RegisteredImage::from_svg_at_size(width, height, data)?,
)?;
Ok(handle)
}
pub fn register_embedded_svg_image(
&mut self,
resource: EmbeddedSvgImageResource,
) -> Result<()> {
self.register_image(resource.handle(), resource.registered_image()?)
}
pub fn register_embedded_svg_images(
&mut self,
resources: impl IntoIterator<Item = EmbeddedSvgImageResource>,
) -> Result<()> {
for resource in resources {
self.register_embedded_svg_image(resource)?;
}
Ok(())
}
pub fn build(self) -> Result<Runtime> {
let mut runtime = Runtime::with_registries(
self.next_font_id,
self.font_registry,
self.next_image_id,
self.image_registry,
);
runtime.command_listeners = self.command_listeners;
for window in self.windows {
runtime.add_window(window)?;
}
Ok(runtime)
}
}
impl Default for Application {
fn default() -> Self {
Self {
windows: Vec::new(),
next_font_id: 1,
next_image_id: 1,
font_registry: Arc::new(FontRegistry::new()),
image_registry: Arc::new(ImageRegistry::new()),
command_listeners: CommandListeners::default(),
}
}
}
pub const EXTERNAL_WAKE_KIND: &str = "sui.external.wake";
pub struct Runtime {
next_font_id: u64,
next_image_id: u64,
font_registry: Arc<FontRegistry>,
image_registry: Arc<ImageRegistry>,
text_system: Arc<TextSystem>,
clipboard: Clipboard,
windows: Vec<WindowState>,
external_waker: Option<Arc<dyn Fn() + Send + Sync>>,
command_sender: CommandSender,
command_listeners: CommandListeners,
}
impl Runtime {
pub fn new() -> Self {
Self::with_registries(
1,
Arc::new(FontRegistry::new()),
1,
Arc::new(ImageRegistry::new()),
)
}
fn with_registries(
next_font_id: u64,
font_registry: Arc<FontRegistry>,
next_image_id: u64,
image_registry: Arc<ImageRegistry>,
) -> Self {
Self {
next_font_id: next_font_id.max(1),
next_image_id: next_image_id.max(1),
font_registry,
image_registry,
text_system: Arc::new(TextSystem::new()),
clipboard: Clipboard::new(),
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.clipboard = self.clipboard.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 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.clipboard.clone()
}
pub fn set_clipboard_backend(&self, backend: impl ClipboardBackend + 'static) {
self.clipboard.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.font_registry);
let image_registry = Arc::clone(&self.image_registry);
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.font_registry);
let image_registry = Arc::clone(&self.image_registry);
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 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<()> {
if Arc::make_mut(&mut self.font_registry)
.insert(handle, font)
.is_some()
{
return Err(Error::new(format!(
"font handle {} is already registered",
handle.get()
)));
}
self.next_font_id = self.next_font_id.max(handle.get() + 1);
Ok(())
}
pub fn register_font_bytes(&mut self, data: impl Into<Vec<u8>>) -> Result<FontHandle> {
let handle = FontHandle::new(self.next_font_id.max(1));
self.next_font_id = handle.get() + 1;
self.register_font(handle, RegisteredFont::from_bytes(data))?;
Ok(handle)
}
pub fn register_image(&mut self, handle: ImageHandle, image: RegisteredImage) -> Result<()> {
if Arc::make_mut(&mut self.image_registry)
.insert(handle, image)
.is_some()
{
return Err(Error::new(format!(
"image handle {} is already registered",
handle.get()
)));
}
self.next_image_id = self.next_image_id.max(handle.get() + 1);
Ok(())
}
pub fn register_svg_image_with_handle(
&mut self,
handle: ImageHandle,
data: impl AsRef<[u8]>,
) -> Result<()> {
self.register_image(handle, RegisteredImage::from_svg(data)?)
}
pub fn register_rgba_image(
&mut self,
width: u32,
height: u32,
data: impl Into<Vec<u8>>,
) -> Result<ImageHandle> {
let handle = ImageHandle::new(self.next_image_id.max(1));
self.next_image_id = handle.get() + 1;
self.register_image(handle, RegisteredImage::from_rgba8(width, height, data)?)?;
Ok(handle)
}
pub fn register_svg_image(&mut self, data: impl AsRef<[u8]>) -> Result<ImageHandle> {
let handle = ImageHandle::new(self.next_image_id.max(1));
self.next_image_id = handle.get() + 1;
self.register_image(handle, RegisteredImage::from_svg(data)?)?;
Ok(handle)
}
pub fn register_svg_image_at_size_with_handle(
&mut self,
handle: ImageHandle,
width: u32,
height: u32,
data: impl AsRef<[u8]>,
) -> Result<()> {
self.register_image(
handle,
RegisteredImage::from_svg_at_size(width, height, data)?,
)
}
pub fn register_svg_image_at_size(
&mut self,
width: u32,
height: u32,
data: impl AsRef<[u8]>,
) -> Result<ImageHandle> {
let handle = ImageHandle::new(self.next_image_id.max(1));
self.next_image_id = handle.get() + 1;
self.register_image(
handle,
RegisteredImage::from_svg_at_size(width, height, data)?,
)?;
Ok(handle)
}
pub fn register_embedded_svg_image(
&mut self,
resource: EmbeddedSvgImageResource,
) -> Result<()> {
self.register_image(resource.handle(), resource.registered_image()?)
}
pub fn register_embedded_svg_images(
&mut self,
resources: impl IntoIterator<Item = EmbeddedSvgImageResource>,
) -> Result<()> {
for resource in resources {
self.register_embedded_svg_image(resource)?;
}
Ok(())
}
pub fn font_registry(&self) -> &Arc<FontRegistry> {
&self.font_registry
}
pub fn image_registry(&self) -> &Arc<ImageRegistry> {
&self.image_registry
}
pub fn render(&mut self, window_id: WindowId) -> Result<RenderOutput> {
let text_system = Arc::clone(&self.text_system);
let font_registry = Arc::clone(&self.font_registry);
let image_registry = Arc::clone(&self.image_registry);
let window = self.window_mut(window_id)?;
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 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 {
push_trace(
&mut self.windows[index].pending_command_diagnostics,
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);
push_trace(
&mut self.windows[index].pending_command_diagnostics,
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 {
push_trace(
&mut self.windows[index].pending_command_diagnostics,
command_sample(queued, Vec::new(), false, false),
);
return;
};
let Some(dispatch) =
self.windows[index].dispatch_direct_command(target, queued)
else {
push_trace(
&mut self.windows[index].pending_command_diagnostics,
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);
push_trace(
&mut self.windows[index].pending_command_diagnostics,
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 animations = ctx.take_animation_targets();
for invalidation in invalidations {
self.apply_command_invalidation(invalidation, source, delivery_window);
}
for (window_id, widget_id) in animations {
if let Some(window) = self
.windows
.iter_mut()
.find(|window| window.id == window_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 {
push_trace(&mut self.windows[index].pending_command_diagnostics, sample);
} else {
for window in &mut self.windows {
push_trace(&mut window.pending_command_diagnostics, 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, 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 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 stack_order_policy: StackOrderPolicy,
pub accepts_focus: bool,
pub focused: 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 {
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_effect: DropEffect,
preview_label: Option<Arc<str>>,
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_effect: request.allowed_effect,
preview_label: request.preview_label.map(Arc::from),
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_effect,
accepted_effect,
preview_label: self.preview_label.clone(),
outcome,
})
}
}
struct WindowState {
id: WindowId,
title: String,
icon: Option<WindowIcon>,
root: WidgetPod,
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_semantics: Vec<SemanticsNode>,
pending_invalidations: Vec<InvalidationRequest>,
pending_reactive_diagnostics: Vec<ReactiveInvalidationSample>,
reactive_hub: Arc<reactive::ReactiveInvalidationHub>,
pointer_capture: HashMap<u64, WidgetId>,
last_pointer_events: HashMap<u64, PointerEvent>,
pointer_hover_paths: HashMap<u64, Vec<WidgetId>>,
active_drag: Option<ActiveDrag>,
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>,
last_animation_frame_time: Option<f64>,
next_animation_frame_index: u64,
pending_animation_wake_count: usize,
ime_composition_rect: Option<Rect>,
last_tick_time: f64,
clipboard: Clipboard,
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,
}
impl WindowState {
fn new(
id: WindowId,
title: String,
icon: Option<WindowIcon>,
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,
graph: WidgetGraph::empty(root.id()),
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_semantics: Vec::new(),
pending_invalidations: Vec::new(),
pending_reactive_diagnostics: Vec::new(),
reactive_hub,
pointer_capture: HashMap::new(),
last_pointer_events: HashMap::new(),
pointer_hover_paths: HashMap::new(),
active_drag: None,
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(),
last_animation_frame_time: None,
next_animation_frame_index: 0,
pending_animation_wake_count: 0,
ime_composition_rect: None,
last_tick_time: 0.0,
clipboard: Clipboard::new(),
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(),
}
}
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) 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 {
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;
};
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()
}
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 {
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.active_drag = None;
}
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;
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_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.clipboard,
&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.clipboard,
&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.clipboard,
&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.clipboard,
&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 animation_frame_deadline(&self) -> Option<f64> {
(!self.requested_animation_frames.is_empty()).then_some(
self.last_animation_frame_time
.map_or(self.last_tick_time, |last| {
last + ANIMATION_FRAME_INTERVAL_SECONDS
}),
)
}
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())
.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)
{
let delta = self
.last_animation_frame_time
.map(|last| (now - last).max(0.0))
.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());
ready.extend(requested.iter().map(|_| {
Event::Wake(WakeEvent::AnimationFrame {
time: now,
delta,
frame_index,
})
}));
self.last_animation_frame_time = Some(now);
} else if self.delivering_animation_frames.is_empty()
&& self.requested_animation_frames.is_empty()
{
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::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::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_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_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_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 {
push_trace(
&mut self.pending_command_diagnostics,
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_drag_requests(dispatch.drag_requests, invalidations);
self.apply_posted_events(dispatch.posted_events, invalidations);
posted.extend(dispatch.posted_commands);
push_trace(
&mut self.pending_command_diagnostics,
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,
));
}
}
}
}
fn handle_drag_pointer_event(
&mut self,
pointer: &PointerEvent,
hit_target: Option<WidgetId>,
) -> EventEffects {
if self
.active_drag
.as_ref()
.is_none_or(|drag| drag.pointer_id != pointer.pointer_id)
{
return EventEffects::default();
}
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();
};
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);
}
}
}
}
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 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 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);
}
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.requested_animation_frames.is_empty()
{
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.clipboard,
&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.clipboard,
&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.clipboard,
&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.clipboard,
&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,
};
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.clipboard,
&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.clipboard,
&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.clipboard,
&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.clipboard,
&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::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 mut repainted = false;
let mut repaint_layers = Vec::new();
let mut dirty_layers = Vec::new();
let mut layer_updates = Vec::new();
let previous_graph =
if (self.schedule.measure || self.schedule.arrange) && !self.graph.is_empty() {
Some(self.graph.snapshot())
} else {
None
};
let mut graph_changes = GraphChangeSet::default();
if self.last_frame.is_none() {
self.schedule = FrameSchedule::bootstrap();
}
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 = self.collect_graph_changes(previous_graph.as_ref());
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());
}
}
self.apply_pending_overlay_focus(&mut invalidations);
let viewport = self.viewport.unwrap_or(Size::ZERO);
let dpi_info = self.dpi_info_for_viewport(viewport);
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,
paint_invalidations,
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(),
Vec::new(),
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);
invalidations.extend(paint_invalidations);
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);
retain_text_layouts_for_scene(text_system.as_ref(), &scene);
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,
);
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,
diagnostics,
}
}
fn frame_image_registry(
&self,
base: Arc<ImageRegistry>,
paint_images: Vec<(ImageHandle, PaintImageResource)>,
) -> Arc<ImageRegistry> {
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 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),
);
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 invalidations = Vec::new();
let mut paint_bounds_by_widget = self.last_paint_bounds_by_widget.clone();
let mut ime_composition_rect = baseline_ime_composition_rect;
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)),
);
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_invalidations,
layer_ime_composition_rect,
) = paint_ctx.into_parts();
let Some(descriptor) = self.root.layer_descriptor_for(widget_id, &layer_scene) 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);
invalidations.extend(layer_invalidations);
if layer_ime_composition_rect.is_some() {
ime_composition_rect = layer_ime_composition_rect;
}
}
(
scene,
images,
paint_bounds_by_widget,
invalidations,
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<&WidgetGraphSnapshot>) -> GraphChangeSet {
let Some(previous) = previous else {
return GraphChangeSet {
repaint_widgets: vec![self.graph.root],
transform_widgets: Vec::new(),
};
};
let current_snapshot = self.graph.snapshot();
let previous_nodes: HashMap<_, _> =
previous.nodes.iter().map(|node| (node.id, node)).collect();
let current_nodes: HashMap<_, _> = current_snapshot
.nodes
.iter()
.map(|node| (node.id, node))
.collect();
let widget_ids = previous_nodes
.keys()
.chain(current_nodes.keys())
.copied()
.collect::<HashSet<_>>();
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
{
repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
¤t_snapshot,
current_node.id,
));
continue;
}
let delta = current_node.geometry.layout_bounds.origin
- previous_node.geometry.layout_bounds.origin;
if delta != Vector::ZERO {
let resolved_boundary = resolve_snapshot_paint_boundary_or_root(
¤t_snapshot,
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
&& current_boundary.geometry.layout_bounds.origin
- previous_boundary.geometry.layout_bounds.origin
== delta
})
{
} else {
repaint_candidates.insert(resolved_boundary);
}
}
}
(None, Some(current_node)) => {
repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
¤t_snapshot,
current_node.id,
));
}
(Some(previous_node), None) => {
repaint_candidates.insert(resolve_snapshot_paint_boundary_or_root(
previous,
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 {
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();
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) 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 {
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 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);
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.last_tick_time,
);
let measured_root = if self.schedule.measure || self.viewport.is_none() {
self.root.measure(&mut measure_ctx, constraints)
} else {
self.root.measured_size()
};
let viewport = constraints.clamp(measured_root);
let mut arrange_ctx = ArrangeCtx::new_at(
self.id,
self.root.id(),
self.current_dpi_info(),
self.last_tick_time,
);
self.root.arrange(
&mut arrange_ctx,
Rect::from_origin_size(Point::ZERO, viewport),
);
self.viewport = Some(viewport);
self.schedule.measure = false;
self.schedule.arrange = false;
self.schedule.hit_test = false;
self.refresh_graph();
let mut invalidations = measure_ctx.take_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) {
self.graph = WidgetGraph::rebuild(
&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;
}
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) {
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 prune_runtime_state(&mut self) {
self.pointer_capture
.retain(|_, widget_id| self.graph.contains(*widget_id));
if self
.active_drag
.as_ref()
.is_some_and(|drag| !self.graph.contains(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));
if self.requested_animation_frames.is_empty() && self.delivering_animation_frames.is_empty()
{
self.last_animation_frame_time = None;
}
if self
.focus
.focused_widget
.is_some_and(|widget_id| !self.graph.contains(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.or(self.viewport_hint).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) {
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: HashSet<_> = 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: &HashSet<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: HashMap<WidgetId, WidgetNodeSnapshot>,
order: Vec<WidgetId>,
host_surface_order: HashMap<WidgetId, Vec<WidgetId>>,
host_order_policy: HashMap<WidgetId, StackOrderPolicy>,
overlay_options: HashMap<WidgetId, OverlayOptions>,
overlay_parents: HashMap<WidgetId, Option<WidgetId>>,
overlay_surfaces: HashMap<WidgetId, Vec<WidgetId>>,
}
#[derive(Clone, Copy)]
struct GraphCollectContext {
stack_host: WidgetId,
stack_surface: WidgetId,
overlay_owner: Option<WidgetId>,
}
impl WidgetGraph {
fn empty(root: WidgetId) -> Self {
Self {
root,
nodes: HashMap::new(),
order: Vec::new(),
host_surface_order: HashMap::new(),
host_order_policy: HashMap::new(),
overlay_options: HashMap::new(),
overlay_parents: HashMap::new(),
overlay_surfaces: HashMap::new(),
}
}
fn rebuild(
root: &WidgetPod,
focused_widget: Option<WidgetId>,
paint_bounds_by_widget: &HashMap<WidgetId, Rect>,
) -> Self {
let mut graph = Self::empty(root.id());
graph.collect(
root,
None,
focused_widget,
paint_bounds_by_widget,
GraphCollectContext {
stack_host: root.id(),
stack_surface: root.id(),
overlay_owner: None,
},
);
graph.recompute_stack_surface_order();
graph
}
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 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,
) {
let id = pod.id();
self.order.push(id);
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 = 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 visitor = CollectChildrenVisitor {
graph: self,
parent: id,
focused_widget,
paint_bounds_by_widget,
context: GraphCollectContext {
stack_host: resolved_host,
stack_surface: resolved_surface,
overlay_owner,
},
children: Vec::new(),
};
pod.visit_children(&mut visitor);
visitor.children
};
let layout_bounds = pod.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),
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,
stack_order_policy: resolved_policy,
accepts_focus: pod.accepts_focus(),
focused: Some(id) == focused_widget,
},
);
}
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;
}
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 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);
}
}
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>,
}
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,
);
}
}
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>,
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.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.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(),
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::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::Drag(_) => "drag",
Event::Keyboard(_) => "keyboard",
Event::Ime(_) => "ime",
Event::Semantics(_) => "semantics",
Event::Wake(_) => "wake",
Event::Window(_) => "window",
Event::Custom(_) => "custom",
}
}
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
}
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 resolve_snapshot_paint_boundary_or_root(
snapshot: &WidgetGraphSnapshot,
widget_id: WidgetId,
) -> WidgetId {
let nodes = snapshot
.nodes
.iter()
.map(|node| (node.id, node))
.collect::<HashMap<_, _>>();
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;
}
snapshot.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 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 {
use std::{
cell::RefCell,
collections::VecDeque,
path::PathBuf,
rc::Rc,
sync::{
Arc, Mutex,
atomic::{AtomicUsize, Ordering},
},
};
use super::{
Application, ArrangeCtx, Command, CommandController, CommandCtx, CommandKey, CommandTarget,
EventCtx, EventPhase, EventRoutePhase, FocusScope, FocusScopeState, FocusState,
FrameSchedule, LayerOptions, MeasureCtx, OVERLAY_DISMISS_REQUEST, OverlayDismissReason,
OverlayFocusBehavior, OverlayKind, OverlayOptions, OverlayTraceKind, PaintBoundaryMode,
PaintCtx, RenderOutput, Runtime, SceneStatisticsDetailMode, SemanticsCtx, SingleChild,
StackSurfaceOptions, Widget, WidgetChildren, WidgetDiagnosticsCtx, WidgetGraphSnapshot,
WidgetNodeSnapshot, WidgetPodMutVisitor, WidgetPodVisitor, WindowBuilder, WindowIcon,
WindowRenderOptions, set_window_render_options, set_window_scene_statistics_detail_mode,
window_render_options,
};
use sui_core::{
AsyncWakeToken, Color, CustomEvent, DragEventKind, DragOutcome, DragPayload, DragScopeId,
DragSessionId, DropEffect, Event, FontHandle, ImageHandle, InvalidationKind, KeyState,
KeyboardEvent, Point, PointerButton, PointerButtons, PointerEvent, PointerEventKind,
PointerKind, Rect, SemanticsAction, SemanticsActionRequest, SemanticsNode, SemanticsRole,
SemanticsValue, Size, TimerToken, Vector, WakeEvent, WidgetId, WindowEvent,
};
use sui_layout::Constraints;
use sui_reactive::Signal;
use sui_scene::{
LayerCompositionMode, LayerProperties, RegisteredExternalImage, RegisteredImage, Scene,
SceneCommand, SceneLayerUpdateKind,
};
use sui_text::{PersistentTextLayout, RegisteredFont, TextStyle, TextSystem};
#[derive(Default)]
struct Counters {
paint: usize,
semantics: usize,
keyboard: usize,
focus_changes: usize,
}
struct FocusLeaf {
counters: Rc<RefCell<Counters>>,
}
struct WindowEventRecorder {
events: Rc<RefCell<Vec<WindowEvent>>>,
}
impl Widget for WindowEventRecorder {
fn event(&mut self, _ctx: &mut EventCtx, event: &Event) {
if let Event::Window(event) = event {
self.events.borrow_mut().push(event.clone());
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 80.0))
}
}
const SYNTHETIC_ACTION_ID: WidgetId = WidgetId::new(u64::MAX - 1);
#[derive(Debug, Default)]
struct SemanticActionState {
actions: Vec<(WidgetId, SemanticsActionRequest)>,
pointer_activations: usize,
disabled: bool,
expanded: bool,
}
struct SyntheticSemanticActionLeaf {
state: Rc<RefCell<SemanticActionState>>,
}
struct UnfocusableSemanticLeaf;
impl Widget for UnfocusableSemanticLeaf {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
node.name = Some("unfocusable semantic node".to_string());
node.actions = vec![SemanticsAction::Focus];
ctx.push(node);
}
}
impl Widget for SyntheticSemanticActionLeaf {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
match event {
Event::Semantics(event) => {
self.state
.borrow_mut()
.actions
.push((event.target, event.action.clone()));
if !matches!(
event.action,
SemanticsActionRequest::Activate
| SemanticsActionRequest::Blur
| SemanticsActionRequest::Expand
| SemanticsActionRequest::Collapse
) {
ctx.set_handled();
}
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Up => {
let mut state = self.state.borrow_mut();
state.pointer_activations += 1;
state.expanded = !state.expanded;
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(160.0, 64.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.fill_bounds(Color::rgba(0.16, 0.24, 0.34, 1.0));
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut owner = SemanticsNode::new(
ctx.widget_id(),
SemanticsRole::GenericContainer,
ctx.bounds(),
);
owner.name = Some("semantic action owner".to_string());
ctx.push(owner);
let mut action = SemanticsNode::new(
SYNTHETIC_ACTION_ID,
SemanticsRole::Button,
Rect::new(ctx.bounds().x() + 8.0, ctx.bounds().y() + 8.0, 80.0, 32.0),
);
action.parent = Some(ctx.widget_id());
action.name = Some("virtual action".to_string());
let state = self.state.borrow();
action.state.disabled = state.disabled;
action.state.expanded = Some(state.expanded);
action.actions = vec![
SemanticsAction::Focus,
SemanticsAction::Blur,
SemanticsAction::Activate,
SemanticsAction::Expand,
SemanticsAction::Collapse,
SemanticsAction::SetValue,
SemanticsAction::InsertText,
];
ctx.push(action);
}
fn accepts_focus(&self) -> bool {
true
}
}
impl Widget for FocusLeaf {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if let Event::Keyboard(_) = event {
self.counters.borrow_mut().keyboard += 1;
ctx.set_handled();
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.counters.borrow_mut().paint += 1;
ctx.fill_bounds(Color::rgba(0.22, 0.31, 0.42, 1.0));
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.counters.borrow_mut().semantics += 1;
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
node.name = Some("focus-leaf".to_string());
node.actions = vec![SemanticsAction::Focus, SemanticsAction::Blur];
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
true
}
fn focus_changed(&mut self, ctx: &mut EventCtx, _focused: bool) {
self.counters.borrow_mut().focus_changes += 1;
ctx.request_paint_rect(ctx.bounds());
ctx.request_semantics();
}
}
#[test]
fn focus_scope_restores_the_last_focused_descendant() {
let state = FocusScopeState::new();
let mut runtime = Application::new()
.window(
WindowBuilder::new().title("Focus Scope").root(
FocusScope::new(FocusLeaf {
counters: Rc::new(RefCell::new(Counters::default())),
})
.state(state.clone()),
),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let target = runtime
.render(window_id)
.unwrap()
.semantics
.into_iter()
.find(|node| node.name.as_deref() == Some("focus-leaf"))
.unwrap()
.id;
assert!(
runtime
.handle_semantics_action(window_id, target, SemanticsActionRequest::Focus)
.unwrap()
);
let _ = runtime.render(window_id).unwrap();
assert_eq!(state.last_focused(), Some(target));
assert!(
runtime
.handle_semantics_action(window_id, target, SemanticsActionRequest::Blur)
.unwrap()
);
assert_eq!(runtime.focused_widget(window_id).unwrap(), None);
state.request_restore();
let _ = runtime.render(window_id).unwrap();
let ready = runtime.drain_ready_events();
assert_eq!(ready.len(), 1);
for (ready_window, event) in ready {
runtime.handle_event(ready_window, event).unwrap();
}
assert_eq!(runtime.focused_widget(window_id).unwrap(), Some(target));
}
struct TestRoot {
counters: Rc<RefCell<Counters>>,
child: SingleChild,
}
impl Widget for TestRoot {
fn diagnostics(&self, ctx: &mut WidgetDiagnosticsCtx) {
ctx.record("test state", "available");
}
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if let Event::Custom(custom) = event
&& custom.kind == "semantics-only"
{
ctx.request_semantics();
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.child
.measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.child.arrange(
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
);
}
fn paint(&self, ctx: &mut PaintCtx) {
self.counters.borrow_mut().paint += 1;
ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
self.child.paint(ctx);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.counters.borrow_mut().semantics += 1;
ctx.push(SemanticsNode::new(
ctx.widget_id(),
SemanticsRole::Window,
ctx.bounds(),
));
self.child.semantics(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.child.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.child.visit_children_mut(visitor);
}
}
#[derive(Debug, Default)]
struct VirtualizedPaintState {
painted: Vec<usize>,
}
struct VirtualizedLeaf {
index: usize,
state: Rc<RefCell<VirtualizedPaintState>>,
}
impl Widget for VirtualizedLeaf {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(48.0, 24.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.state.borrow_mut().painted.push(self.index);
ctx.fill_bounds(Color::rgba(0.18, 0.31, 0.42, 1.0));
}
}
struct VirtualizedLogicalRoot {
children: WidgetChildren,
visible_count: usize,
}
impl VirtualizedLogicalRoot {
fn new(
logical_count: usize,
visible_count: usize,
state: Rc<RefCell<VirtualizedPaintState>>,
) -> Self {
let mut children = WidgetChildren::with_capacity(logical_count);
for index in 0..logical_count {
children.push(VirtualizedLeaf {
index,
state: Rc::clone(&state),
});
}
Self {
children,
visible_count,
}
}
}
impl Widget for VirtualizedLogicalRoot {
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
for index in 0..self.children.len() {
self.children
.measure_child(index, ctx, Constraints::tight(Size::new(48.0, 24.0)));
}
constraints.clamp(Size::new(320.0, 180.0))
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
for index in 0..self.children.len() {
self.children.arrange_child(
index,
ctx,
Rect::new(bounds.x() + (index as f32 * 52.0), bounds.y(), 48.0, 24.0),
);
}
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
for child in self.children.as_slice().iter().take(self.visible_count) {
child.paint(ctx);
}
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.children.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.children.visit_children_mut(visitor);
}
}
#[derive(Debug, Default)]
struct ThreadedSnapshotState {
async_token: Option<AsyncWakeToken>,
latest: Option<String>,
paints: usize,
}
struct ThreadedSnapshotRoot {
local: Rc<RefCell<ThreadedSnapshotState>>,
inbox: Arc<Mutex<VecDeque<String>>>,
}
impl Widget for ThreadedSnapshotRoot {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
match event {
Event::Custom(custom) if custom.kind == "arm-threaded-snapshot" => {
self.local.borrow_mut().async_token = Some(ctx.register_async_wakeup());
ctx.set_handled();
}
Event::Wake(WakeEvent::Async { token, .. }) => {
let mut local = self.local.borrow_mut();
if local.async_token == Some(*token) {
while let Some(value) = self.inbox.lock().unwrap().pop_front() {
local.latest = Some(value);
}
ctx.request_paint();
ctx.set_handled();
}
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(160.0, 64.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.local.borrow_mut().paints += 1;
let active = self.local.borrow().latest.is_some();
let color = if active {
Color::rgba(0.20, 0.46, 0.30, 1.0)
} else {
Color::rgba(0.20, 0.24, 0.32, 1.0)
};
ctx.fill_bounds(color);
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
struct CachedLayerPresentation {
translation: Vector,
opacity: f32,
}
impl Default for CachedLayerPresentation {
fn default() -> Self {
Self {
translation: Vector::ZERO,
opacity: 1.0,
}
}
}
struct CachedMoveLeaf {
counters: Rc<RefCell<Counters>>,
presentation: Rc<RefCell<CachedLayerPresentation>>,
}
impl Widget for CachedMoveLeaf {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(220.0, 72.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.counters.borrow_mut().paint += 1;
ctx.fill_bounds(Color::rgba(0.14, 0.42, 0.72, 1.0));
}
fn layer_options(&self) -> LayerOptions {
LayerOptions {
paint_boundary: PaintBoundaryMode::Explicit,
composition_mode: sui_scene::LayerCompositionMode::Scroll,
}
}
fn layer_properties(&self) -> LayerProperties {
let presentation = *self.presentation.borrow();
LayerProperties::default()
.with_translation(presentation.translation)
.with_opacity(presentation.opacity)
}
}
struct DirectMoveLeaf {
counters: Rc<RefCell<Counters>>,
}
impl Widget for DirectMoveLeaf {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(140.0, 48.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
self.counters.borrow_mut().paint += 1;
ctx.fill_bounds(Color::rgba(0.78, 0.43, 0.14, 1.0));
}
}
struct OverpaintLeaf {
size: Size,
color: Color,
bleed: Vector,
}
impl Widget for OverpaintLeaf {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(self.size)
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.fill_rect(
ctx.bounds().inflate(self.bleed.x.abs(), self.bleed.y.abs()),
self.color,
);
}
}
struct PointerCountingLeaf {
pointer_downs: Rc<RefCell<usize>>,
}
impl Widget for PointerCountingLeaf {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if matches!(
event,
Event::Pointer(pointer)
if pointer.kind == PointerEventKind::Down
&& pointer.button == Some(PointerButton::Primary)
) {
*self.pointer_downs.borrow_mut() += 1;
ctx.set_handled();
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.fill_bounds(Color::rgba(0.15, 0.35, 0.58, 1.0));
}
}
struct NonHitTestOverlayLeaf;
impl Widget for NonHitTestOverlayLeaf {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.fill_bounds(Color::rgba(0.9, 0.2, 0.2, 0.35));
}
fn layer_options(&self) -> LayerOptions {
LayerOptions {
paint_boundary: PaintBoundaryMode::Explicit,
composition_mode: LayerCompositionMode::Overlay,
}
}
fn stack_surface_options(&self) -> Option<StackSurfaceOptions> {
Some(StackSurfaceOptions {
hit_test: false,
..StackSurfaceOptions::default()
})
}
}
struct OverlayPassThroughRoot {
children: WidgetChildren,
}
impl OverlayPassThroughRoot {
fn new(pointer_downs: Rc<RefCell<usize>>) -> Self {
let mut children = WidgetChildren::with_capacity(2);
children.push(PointerCountingLeaf { pointer_downs });
children.push(NonHitTestOverlayLeaf);
Self { children }
}
}
impl Widget for OverlayPassThroughRoot {
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.children
.measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
self.children
.measure_child(1, ctx, Constraints::tight(Size::new(120.0, 40.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
let child_bounds = Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0);
self.children.arrange_child(0, ctx, child_bounds);
self.children.arrange_child(1, ctx, child_bounds);
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
self.children.paint(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.children.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.children.visit_children_mut(visitor);
}
}
struct HitTestOverlaySurface {
child: SingleChild,
}
impl HitTestOverlaySurface {
fn new(pointer_downs: Rc<RefCell<usize>>) -> Self {
Self {
child: SingleChild::new(PointerCountingLeaf { pointer_downs }),
}
}
}
impl Widget for HitTestOverlaySurface {
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.child
.measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
constraints.clamp(Size::new(180.0, 90.0))
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.child.arrange(
ctx,
Rect::new(bounds.x() + 24.0, bounds.y() + 20.0, 120.0, 40.0),
);
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.fill_bounds(Color::rgba(0.9, 0.2, 0.2, 0.35));
self.child.paint(ctx);
}
fn layer_options(&self) -> LayerOptions {
LayerOptions {
paint_boundary: PaintBoundaryMode::Explicit,
composition_mode: LayerCompositionMode::Effect,
}
}
fn stack_surface_options(&self) -> Option<StackSurfaceOptions> {
Some(StackSurfaceOptions::default())
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.child.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.child.visit_children_mut(visitor);
}
}
struct HitTestOverlayRoot {
child: SingleChild,
}
impl HitTestOverlayRoot {
fn new(pointer_downs: Rc<RefCell<usize>>) -> Self {
Self {
child: SingleChild::new(HitTestOverlaySurface::new(pointer_downs)),
}
}
}
impl Widget for HitTestOverlayRoot {
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.child
.measure(ctx, Constraints::tight(Size::new(180.0, 90.0)));
constraints.clamp(Size::new(320.0, 180.0))
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.child.arrange(
ctx,
Rect::new(bounds.x() + 20.0, bounds.y() + 20.0, 180.0, 90.0),
);
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
self.child.paint(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.child.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.child.visit_children_mut(visitor);
}
}
struct DirectMoveRoot {
counters: Rc<RefCell<Counters>>,
child: SingleChild,
offset_x: f32,
}
impl Widget for DirectMoveRoot {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if let Event::Custom(custom) = event
&& custom.kind == "shift-direct"
{
self.offset_x += 36.0;
ctx.request_arrange();
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.child
.measure(ctx, Constraints::tight(Size::new(140.0, 48.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.child.arrange(
ctx,
Rect::new(
bounds.x() + 28.0 + self.offset_x,
bounds.y() + 32.0,
140.0,
48.0,
),
);
}
fn paint(&self, ctx: &mut PaintCtx) {
self.counters.borrow_mut().paint += 1;
ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
self.child.paint(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.child.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.child.visit_children_mut(visitor);
}
}
struct CachedMoveRoot {
counters: Rc<RefCell<Counters>>,
child: SingleChild,
presentation: Rc<RefCell<CachedLayerPresentation>>,
offset_x: f32,
paint_background: bool,
}
impl Widget for CachedMoveRoot {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if let Event::Custom(custom) = event
&& custom.kind == "shift-cached"
{
self.offset_x += 48.0;
ctx.request_arrange();
}
if let Event::Custom(custom) = event
&& custom.kind == "nudge-cached-layer-property"
{
self.presentation.borrow_mut().translation += Vector::new(18.0, 0.0);
ctx.request_transform();
}
if let Event::Custom(custom) = event
&& custom.kind == "fade-cached-layer"
{
self.presentation.borrow_mut().opacity = 0.5;
ctx.request_effect();
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.child
.measure(ctx, Constraints::tight(Size::new(220.0, 72.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.child.arrange(
ctx,
Rect::new(
bounds.x() + 24.0 + self.offset_x,
bounds.y() + 28.0,
220.0,
72.0,
),
);
}
fn paint(&self, ctx: &mut PaintCtx) {
self.counters.borrow_mut().paint += 1;
if self.paint_background {
ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
}
self.child.paint(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.child.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.child.visit_children_mut(visitor);
}
}
struct FocusTraversalRoot {
children: WidgetChildren,
}
struct ManagedOverlayTestRoot {
open: Rc<RefCell<bool>>,
children: WidgetChildren,
}
impl ManagedOverlayTestRoot {
fn new(
open: Rc<RefCell<bool>>,
dismissals: Rc<RefCell<Vec<OverlayDismissReason>>>,
) -> Self {
let mut overlay_children = WidgetChildren::with_capacity(2);
overlay_children.push(FocusLeaf {
counters: Rc::new(RefCell::new(Counters::default())),
});
overlay_children.push(FocusLeaf {
counters: Rc::new(RefCell::new(Counters::default())),
});
let mut children = WidgetChildren::with_capacity(2);
children.push(FocusLeaf {
counters: Rc::new(RefCell::new(Counters::default())),
});
children.push(ManagedOverlayTestWidget {
open: Rc::clone(&open),
dismissals,
children: overlay_children,
});
Self { open, children }
}
}
impl Widget for ManagedOverlayTestRoot {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if let Event::Custom(custom) = event
&& custom.kind == "open-managed-overlay"
{
*self.open.borrow_mut() = true;
ctx.request_measure();
ctx.request_semantics();
ctx.set_handled();
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(360.0, 220.0));
self.children
.measure_child(0, ctx, Constraints::tight(Size::new(100.0, 40.0)));
self.children
.measure_child(1, ctx, Constraints::tight(Size::new(160.0, 120.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.children.arrange_child(
0,
ctx,
Rect::new(bounds.x() + 20.0, bounds.y() + 20.0, 100.0, 40.0),
);
self.children.arrange_child(
1,
ctx,
Rect::new(bounds.x() + 160.0, bounds.y() + 20.0, 160.0, 120.0),
);
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
self.children.paint(ctx);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
ctx.push(SemanticsNode::new(
ctx.widget_id(),
SemanticsRole::Window,
ctx.bounds(),
));
self.children.semantics(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.children.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.children.visit_children_mut(visitor);
}
}
struct ManagedOverlayTestWidget {
open: Rc<RefCell<bool>>,
dismissals: Rc<RefCell<Vec<OverlayDismissReason>>>,
children: WidgetChildren,
}
impl Widget for ManagedOverlayTestWidget {
fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
let Some(request) = command.get(OVERLAY_DISMISS_REQUEST) else {
return;
};
self.dismissals.borrow_mut().push(request.reason);
*self.open.borrow_mut() = false;
ctx.request_measure();
ctx.request_semantics();
ctx.set_handled();
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(160.0, 120.0));
self.children
.measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
self.children
.measure_child(1, ctx, Constraints::tight(Size::new(120.0, 40.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.children.arrange_child(
0,
ctx,
Rect::new(bounds.x() + 20.0, bounds.y() + 12.0, 120.0, 40.0),
);
self.children.arrange_child(
1,
ctx,
Rect::new(bounds.x() + 20.0, bounds.y() + 64.0, 120.0, 40.0),
);
}
fn paint(&self, ctx: &mut PaintCtx) {
self.children.paint(ctx);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
if *self.open.borrow() {
let mut node =
SemanticsNode::new(ctx.widget_id(), SemanticsRole::Dialog, ctx.bounds());
node.name = Some("managed overlay".to_string());
ctx.push(node);
}
self.children.semantics(ctx);
}
fn overlay_options(&self) -> Option<OverlayOptions> {
(*self.open.borrow()).then_some(
OverlayOptions::new(OverlayKind::Dialog)
.modal(true)
.focus(OverlayFocusBehavior::CONTAINED),
)
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.children.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.children.visit_children_mut(visitor);
}
}
impl FocusTraversalRoot {
fn new(first: Rc<RefCell<Counters>>, second: Rc<RefCell<Counters>>) -> Self {
let mut children = WidgetChildren::with_capacity(2);
children.push(FocusLeaf { counters: first });
children.push(FocusLeaf { counters: second });
Self { children }
}
}
impl Widget for FocusTraversalRoot {
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.children
.measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
self.children
.measure_child(1, ctx, Constraints::tight(Size::new(120.0, 40.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.children.arrange_child(
0,
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
);
self.children.arrange_child(
1,
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 80.0, 120.0, 40.0),
);
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
self.children.paint(ctx);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
ctx.push(SemanticsNode::new(
ctx.widget_id(),
SemanticsRole::Window,
ctx.bounds(),
));
self.children.semantics(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.children.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.children.visit_children_mut(visitor);
}
}
struct HoverTransitionRoot {
children: WidgetChildren,
}
impl HoverTransitionRoot {
fn new(
first: Rc<RefCell<HoverTransitionState>>,
second: Rc<RefCell<HoverTransitionState>>,
) -> Self {
let mut children = WidgetChildren::with_capacity(2);
children.push(HoverTransitionLeaf {
name: "hover-first",
state: first,
});
children.push(HoverTransitionLeaf {
name: "hover-second",
state: second,
});
Self { children }
}
}
impl Widget for HoverTransitionRoot {
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.children
.measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
self.children
.measure_child(1, ctx, Constraints::tight(Size::new(120.0, 40.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.children.arrange_child(
0,
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
);
self.children.arrange_child(
1,
ctx,
Rect::new(bounds.x() + 172.0, bounds.y() + 24.0, 120.0, 40.0),
);
}
fn paint(&self, ctx: &mut PaintCtx) {
ctx.clear(Color::rgba(0.08, 0.09, 0.11, 1.0));
self.children.paint(ctx);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
ctx.push(SemanticsNode::new(
ctx.widget_id(),
SemanticsRole::Window,
ctx.bounds(),
));
self.children.semantics(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.children.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.children.visit_children_mut(visitor);
}
}
#[derive(Default)]
struct PointerCaptureState {
moves: usize,
ups: usize,
cancels: usize,
cancel_followups: usize,
last_cancel: Option<PointerEvent>,
}
#[derive(Debug, Default)]
struct RuntimeDragState {
source_moves: usize,
target_overs: usize,
drops: usize,
ends: usize,
outcome: Option<DragOutcome>,
}
#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
struct HoverTransitionState {
enters: usize,
leaves: usize,
hovered: bool,
}
struct PointerCaptureLeaf {
state: Rc<RefCell<PointerCaptureState>>,
recapture_on_move: bool,
}
struct PointerCaptureTransferRoot {
child: SingleChild,
}
#[derive(Default)]
struct ReentrantCaptureState {
intermediate_id: Option<WidgetId>,
pointer_id: Option<u64>,
source_cancels: usize,
intermediate_captures: usize,
intermediate_cancels: usize,
}
struct ReentrantCaptureSource {
state: Rc<RefCell<ReentrantCaptureState>>,
}
struct ReentrantCaptureIntermediate {
state: Rc<RefCell<ReentrantCaptureState>>,
}
struct ReentrantCaptureRoot {
children: WidgetChildren,
}
struct RuntimeDragSource {
state: Rc<RefCell<RuntimeDragState>>,
scope: DragScopeId,
session: Option<DragSessionId>,
}
struct RuntimeDragTarget {
state: Rc<RefCell<RuntimeDragState>>,
scope: DragScopeId,
}
struct RuntimeDragRoot {
children: WidgetChildren,
}
struct HoverTransitionLeaf {
name: &'static str,
state: Rc<RefCell<HoverTransitionState>>,
}
impl Widget for PointerCaptureLeaf {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if let Event::Custom(custom) = event
&& custom.kind == "pointer-cancel-followup"
{
self.state.borrow_mut().cancel_followups += 1;
return;
}
let Event::Pointer(pointer) = event else {
return;
};
match pointer.kind {
PointerEventKind::Down => {
ctx.request_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
PointerEventKind::Move => {
self.state.borrow_mut().moves += 1;
if self.recapture_on_move {
ctx.request_pointer_capture(pointer.pointer_id);
}
ctx.set_handled();
}
PointerEventKind::Up => {
self.state.borrow_mut().ups += 1;
ctx.set_handled();
}
PointerEventKind::Cancel => {
let mut state = self.state.borrow_mut();
state.cancels += 1;
state.last_cancel = Some(pointer.clone());
drop(state);
ctx.release_pointer_capture(pointer.pointer_id);
ctx.request_paint();
ctx.post_event(
ctx.widget_id(),
Event::Custom(CustomEvent::new("pointer-cancel-followup")),
);
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
}
impl PointerCaptureTransferRoot {
fn new(child: PointerCaptureLeaf) -> Self {
Self {
child: SingleChild::new(child),
}
}
}
impl Widget for PointerCaptureTransferRoot {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Move
&& ctx.phase() == EventPhase::Capture
{
ctx.request_pointer_capture(pointer.pointer_id);
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.child
.measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.child.arrange(
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.child.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.child.visit_children_mut(visitor);
}
}
impl ReentrantCaptureRoot {
fn new(state: Rc<RefCell<ReentrantCaptureState>>) -> Self {
let mut children = WidgetChildren::with_capacity(2);
children.push(ReentrantCaptureSource {
state: Rc::clone(&state),
});
children.push(ReentrantCaptureIntermediate { state });
Self { children }
}
}
impl Widget for ReentrantCaptureRoot {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if let Event::Pointer(pointer) = event
&& pointer.kind == PointerEventKind::Move
&& ctx.phase() == EventPhase::Capture
{
ctx.request_pointer_capture(pointer.pointer_id);
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.children
.measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
self.children
.measure_child(1, ctx, Constraints::tight(Size::new(80.0, 40.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.children.arrange_child(
0,
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
);
self.children.arrange_child(
1,
ctx,
Rect::new(bounds.x() + 180.0, bounds.y() + 24.0, 80.0, 40.0),
);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.children.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.children.visit_children_mut(visitor);
}
}
impl Widget for ReentrantCaptureSource {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
let Event::Pointer(pointer) = event else {
return;
};
match pointer.kind {
PointerEventKind::Down => {
ctx.request_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
PointerEventKind::Move => {
ctx.set_handled();
}
PointerEventKind::Cancel => {
let intermediate_id = {
let mut state = self.state.borrow_mut();
state.source_cancels += 1;
state.pointer_id = Some(pointer.pointer_id);
state.intermediate_id.expect("intermediate measured")
};
ctx.release_pointer_capture(pointer.pointer_id);
ctx.post_event(
intermediate_id,
Event::Custom(CustomEvent::new("capture-intermediate")),
);
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
}
impl Widget for ReentrantCaptureIntermediate {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
match event {
Event::Custom(custom) if custom.kind == "capture-intermediate" => {
let pointer_id = self.state.borrow().pointer_id.expect("pointer recorded");
self.state.borrow_mut().intermediate_captures += 1;
ctx.request_pointer_capture(pointer_id);
}
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Cancel => {
self.state.borrow_mut().intermediate_cancels += 1;
ctx.release_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
self.state.borrow_mut().intermediate_id = Some(ctx.widget_id());
constraints.clamp(Size::new(80.0, 40.0))
}
}
impl Widget for RuntimeDragSource {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
match event {
Event::Pointer(pointer) => match pointer.kind {
PointerEventKind::Down => {
ctx.request_pointer_capture(pointer.pointer_id);
ctx.set_handled();
}
PointerEventKind::Move if pointer.buttons.contains(PointerButton::Primary) => {
self.state.borrow_mut().source_moves += 1;
if self.session.is_none() {
self.session = Some(ctx.begin_drag(
self.scope,
pointer.pointer_id,
pointer.position,
DragPayload::text("runtime"),
DropEffect::Move,
Some("runtime".to_string()),
));
}
ctx.set_handled();
}
PointerEventKind::Up => {
ctx.set_handled();
}
_ => {}
},
Event::Drag(drag)
if drag.kind == DragEventKind::End && self.session == Some(drag.session_id) =>
{
let mut state = self.state.borrow_mut();
state.ends += 1;
state.outcome = drag.outcome;
self.session = None;
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
}
impl Widget for RuntimeDragTarget {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
let Event::Drag(drag) = event else {
return;
};
if drag.scope_id != self.scope {
return;
}
match drag.kind {
DragEventKind::Over => {
self.state.borrow_mut().target_overs += 1;
ctx.accept_drop(DropEffect::Move);
}
DragEventKind::Drop => {
self.state.borrow_mut().drops += 1;
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
}
impl RuntimeDragRoot {
fn new(state: Rc<RefCell<RuntimeDragState>>) -> Self {
let scope = DragScopeId::new(77);
let mut children = WidgetChildren::with_capacity(2);
children.push(RuntimeDragSource {
state: Rc::clone(&state),
scope,
session: None,
});
children.push(RuntimeDragTarget { state, scope });
Self { children }
}
}
impl Widget for RuntimeDragRoot {
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.children
.measure_child(0, ctx, Constraints::tight(Size::new(120.0, 40.0)));
self.children
.measure_child(1, ctx, Constraints::tight(Size::new(120.0, 40.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.children.arrange_child(
0,
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
);
self.children.arrange_child(
1,
ctx,
Rect::new(bounds.x() + 172.0, bounds.y() + 24.0, 120.0, 40.0),
);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.children.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.children.visit_children_mut(visitor);
}
}
impl Widget for HoverTransitionLeaf {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
let Event::Pointer(pointer) = event else {
return;
};
let mut state = self.state.borrow_mut();
match pointer.kind {
PointerEventKind::Enter => {
state.enters += 1;
state.hovered = true;
ctx.request_paint();
ctx.request_semantics();
}
PointerEventKind::Leave => {
state.leaves += 1;
state.hovered = false;
ctx.request_paint();
ctx.request_semantics();
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
let color = if self.state.borrow().hovered {
Color::rgba(0.28, 0.45, 0.68, 1.0)
} else {
Color::rgba(0.20, 0.28, 0.38, 1.0)
};
ctx.fill_bounds(color);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Button, ctx.bounds());
node.name = Some(self.name.to_string());
node.state.hovered = self.state.borrow().hovered;
ctx.push(node);
}
}
#[derive(Default)]
struct WakeState {
timer_token: Option<TimerToken>,
async_token: Option<AsyncWakeToken>,
timer_wakes: usize,
async_wakes: usize,
}
struct WakeLeaf {
state: Rc<RefCell<WakeState>>,
}
impl Widget for WakeLeaf {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Down => {
let mut state = self.state.borrow_mut();
state.timer_token = Some(ctx.schedule_timer_after(3.0));
state.async_token = Some(ctx.register_async_wakeup());
ctx.set_handled();
}
Event::Wake(WakeEvent::Timer { token, .. }) => {
let mut state = self.state.borrow_mut();
if state.timer_token == Some(*token) {
state.timer_wakes += 1;
ctx.request_paint();
ctx.set_handled();
}
}
Event::Wake(WakeEvent::Async { token, .. }) => {
let mut state = self.state.borrow_mut();
if state.async_token == Some(*token) {
state.async_wakes += 1;
ctx.request_paint();
ctx.set_handled();
}
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
}
#[derive(Default)]
struct AnimationWakeState {
request_twice: bool,
animation_wakes: usize,
last_animation_time: Option<f64>,
last_animation_delta: Option<f64>,
last_animation_frame_index: Option<u64>,
}
struct AnimationWakeLeaf {
state: Rc<RefCell<AnimationWakeState>>,
}
impl Widget for AnimationWakeLeaf {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
match event {
Event::Pointer(pointer) if pointer.kind == PointerEventKind::Down => {
let request_twice = self.state.borrow().request_twice;
ctx.request_animation_frame();
if request_twice {
ctx.request_animation_frame();
}
ctx.set_handled();
}
Event::Wake(WakeEvent::AnimationFrame {
time,
delta,
frame_index,
}) => {
let mut state = self.state.borrow_mut();
state.animation_wakes += 1;
state.last_animation_time = Some(*time);
state.last_animation_delta = Some(*delta);
state.last_animation_frame_index = Some(*frame_index);
ctx.request_paint();
ctx.set_handled();
}
_ => {}
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 40.0))
}
}
struct AnimationWakeCapturingRoot {
child: SingleChild,
ancestor_wakes: Rc<RefCell<usize>>,
}
impl Widget for AnimationWakeCapturingRoot {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if matches!(event, Event::Wake(WakeEvent::AnimationFrame { .. })) {
*self.ancestor_wakes.borrow_mut() += 1;
ctx.set_handled();
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.child
.measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.child.arrange(
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.child.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.child.visit_children_mut(visitor);
}
}
struct RemovableAnimationRoot {
child: Option<SingleChild>,
}
impl Widget for RemovableAnimationRoot {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if let Event::Custom(custom) = event
&& custom.kind == "drop-animation-child"
{
self.child = None;
ctx.request_measure();
ctx.set_handled();
}
}
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
if let Some(child) = &mut self.child {
child.measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
}
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
if let Some(child) = &mut self.child {
child.arrange(
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
);
}
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
if let Some(child) = &self.child {
child.visit_children(visitor);
}
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
if let Some(child) = &mut self.child {
child.visit_children_mut(visitor);
}
}
}
struct TextImeLeaf {
layout: RefCell<Option<PersistentTextLayout>>,
}
struct FocusedImeLeaf;
impl Widget for FocusedImeLeaf {
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(160.0, 32.0))
}
fn paint(&self, ctx: &mut PaintCtx) {
if ctx.is_focused() {
ctx.set_ime_composition_rect(Rect::new(
ctx.bounds().x() + 8.0,
ctx.bounds().y() + 8.0,
1.0,
16.0,
));
}
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut node =
SemanticsNode::new(ctx.widget_id(), SemanticsRole::TextInput, ctx.bounds());
node.state.focused = ctx.is_focused();
node.actions = vec![SemanticsAction::Focus];
ctx.push(node);
}
fn accepts_focus(&self) -> bool {
true
}
}
impl Widget for TextImeLeaf {
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(160.0, 32.0));
let layout = ctx
.layout()
.shape_text_persistent(None, "compose", size, TextStyle::new(Color::WHITE))
.unwrap();
*self.layout.borrow_mut() = Some(layout);
size
}
fn paint(&self, ctx: &mut PaintCtx) {
let layout = self.layout.borrow();
let layout = layout
.as_ref()
.expect("measure pass should shape text first");
let origin = ctx.bounds().origin;
ctx.draw_persistent_text_layout(origin, layout);
ctx.set_ime_composition_rect(layout.caret_rect(3).translate(origin.to_vector()));
}
fn accepts_focus(&self) -> bool {
true
}
}
struct ChildRoot<W> {
child: SingleChild,
_marker: std::marker::PhantomData<W>,
}
impl<W> ChildRoot<W> {
fn new(child: W) -> Self
where
W: Widget + 'static,
{
Self {
child: SingleChild::new(child),
_marker: std::marker::PhantomData,
}
}
}
impl<W> Widget for ChildRoot<W>
where
W: Widget + 'static,
{
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.child
.measure(ctx, Constraints::tight(Size::new(120.0, 40.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.child.arrange(
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 120.0, 40.0),
);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.child.semantics(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.child.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.child.visit_children_mut(visitor);
}
}
struct PaintedChildRoot<W> {
child: SingleChild,
_marker: std::marker::PhantomData<W>,
}
impl<W> PaintedChildRoot<W> {
fn new(child: W) -> Self
where
W: Widget + 'static,
{
Self {
child: SingleChild::new(child),
_marker: std::marker::PhantomData,
}
}
}
impl<W> Widget for PaintedChildRoot<W>
where
W: Widget + 'static,
{
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let size = constraints.clamp(Size::new(320.0, 180.0));
self.child
.measure(ctx, Constraints::tight(Size::new(160.0, 32.0)));
size
}
fn arrange(&mut self, ctx: &mut ArrangeCtx, bounds: Rect) {
self.child.arrange(
ctx,
Rect::new(bounds.x() + 32.0, bounds.y() + 24.0, 160.0, 32.0),
);
}
fn paint(&self, ctx: &mut PaintCtx) {
self.child.paint(ctx);
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
self.child.semantics(ctx);
}
fn visit_children(&self, visitor: &mut dyn WidgetPodVisitor) {
self.child.visit_children(visitor);
}
fn visit_children_mut(&mut self, visitor: &mut dyn WidgetPodMutVisitor) {
self.child.visit_children_mut(visitor);
}
}
fn build_runtime() -> (
Runtime,
sui_core::WindowId,
Rc<RefCell<Counters>>,
Rc<RefCell<Counters>>,
) {
let root_counters = Rc::new(RefCell::new(Counters::default()));
let leaf_counters = Rc::new(RefCell::new(Counters::default()));
let runtime = Application::new()
.window(WindowBuilder::new().title("Test").root(TestRoot {
counters: Rc::clone(&root_counters),
child: SingleChild::new(FocusLeaf {
counters: Rc::clone(&leaf_counters),
}),
}))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id, root_counters, leaf_counters)
}
fn build_semantics_action_runtime() -> (
Runtime,
sui_core::WindowId,
Rc<RefCell<SemanticActionState>>,
) {
let state = Rc::new(RefCell::new(SemanticActionState::default()));
let runtime = Application::new()
.window(
WindowBuilder::new()
.title("Semantic Actions")
.root(PaintedChildRoot::new(SyntheticSemanticActionLeaf {
state: Rc::clone(&state),
})),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id, state)
}
#[test]
fn window_builder_uses_default_sui_icon() {
let (runtime, window_id, _, _) = build_runtime();
let icon = runtime.window_icon(window_id).unwrap().unwrap();
assert!(matches!(icon, WindowIcon::Svg { .. }));
assert!(
std::str::from_utf8(icon.as_svg().unwrap())
.unwrap()
.contains("SUI logo")
);
}
#[test]
fn window_builder_can_override_or_disable_icon() {
let override_icon = WindowIcon::from_svg("<svg viewBox=\"0 0 1 1\"></svg>");
let runtime = Application::new()
.window(
WindowBuilder::new()
.title("Custom icon")
.icon(override_icon.clone())
.root(FocusLeaf {
counters: Rc::new(RefCell::new(Counters::default())),
}),
)
.window(
WindowBuilder::new()
.title("No icon")
.without_icon()
.root(FocusLeaf {
counters: Rc::new(RefCell::new(Counters::default())),
}),
)
.build()
.unwrap();
let window_ids = runtime.window_ids();
assert_eq!(
runtime.window_icon(window_ids[0]).unwrap(),
Some(&override_icon)
);
assert_eq!(runtime.window_icon(window_ids[1]).unwrap(), None);
}
#[test]
fn independent_runtimes_allocate_distinct_window_ids() {
let first = Application::new()
.window(WindowBuilder::new().title("First").root(FocusLeaf {
counters: Rc::new(RefCell::new(Counters::default())),
}))
.build()
.unwrap();
let second = Application::new()
.window(WindowBuilder::new().title("Second").root(FocusLeaf {
counters: Rc::new(RefCell::new(Counters::default())),
}))
.build()
.unwrap();
assert_ne!(first.window_ids()[0], second.window_ids()[0]);
}
#[test]
fn rgba_window_icon_validates_buffer_shape() {
assert!(WindowIcon::from_rgba8(1, 1, vec![0, 0, 0, 255]).is_ok());
assert!(WindowIcon::from_rgba8(0, 1, Vec::new()).is_err());
assert!(WindowIcon::from_rgba8(1, 1, vec![0, 0, 0]).is_err());
}
fn build_cached_move_runtime() -> (
Runtime,
sui_core::WindowId,
Rc<RefCell<Counters>>,
Rc<RefCell<Counters>>,
) {
let root_counters = Rc::new(RefCell::new(Counters::default()));
let leaf_counters = Rc::new(RefCell::new(Counters::default()));
let presentation = Rc::new(RefCell::new(CachedLayerPresentation::default()));
let runtime = Application::new()
.window(
WindowBuilder::new()
.title("Cached move")
.root(CachedMoveRoot {
counters: Rc::clone(&root_counters),
child: SingleChild::new(CachedMoveLeaf {
counters: Rc::clone(&leaf_counters),
presentation: Rc::clone(&presentation),
}),
presentation,
offset_x: 0.0,
paint_background: true,
}),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id, root_counters, leaf_counters)
}
fn build_direct_move_runtime() -> (
Runtime,
sui_core::WindowId,
Rc<RefCell<Counters>>,
Rc<RefCell<Counters>>,
) {
let root_counters = Rc::new(RefCell::new(Counters::default()));
let leaf_counters = Rc::new(RefCell::new(Counters::default()));
let runtime = Application::new()
.window(
WindowBuilder::new()
.title("Direct move")
.root(DirectMoveRoot {
counters: Rc::clone(&root_counters),
child: SingleChild::new(DirectMoveLeaf {
counters: Rc::clone(&leaf_counters),
}),
offset_x: 0.0,
}),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id, root_counters, leaf_counters)
}
fn build_overpaint_runtime() -> (Runtime, sui_core::WindowId) {
let runtime = Application::new()
.window(WindowBuilder::new().title("Overpaint").root(TestRoot {
counters: Rc::new(RefCell::new(Counters::default())),
child: SingleChild::new(OverpaintLeaf {
size: Size::new(120.0, 40.0),
color: Color::rgba(0.92, 0.42, 0.18, 1.0),
bleed: Vector::new(6.0, 4.0),
}),
}))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id)
}
fn build_focus_traversal_runtime() -> (
Runtime,
sui_core::WindowId,
Rc<RefCell<Counters>>,
Rc<RefCell<Counters>>,
) {
let first = Rc::new(RefCell::new(Counters::default()));
let second = Rc::new(RefCell::new(Counters::default()));
let runtime =
Application::new()
.window(WindowBuilder::new().title("Focus Traversal").root(
FocusTraversalRoot::new(Rc::clone(&first), Rc::clone(&second)),
))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id, first, second)
}
fn graph_child(graph: &WidgetGraphSnapshot) -> &WidgetNodeSnapshot {
&graph.nodes[1]
}
fn scene_has_layer_for(scene: &sui_scene::Scene, widget_id: sui_core::WidgetId) -> bool {
scene.commands().iter().any(|command| match command {
SceneCommand::Layer(layer) => layer.widget_id() == widget_id,
_ => false,
})
}
fn build_pointer_capture_runtime() -> (
Runtime,
sui_core::WindowId,
Rc<RefCell<PointerCaptureState>>,
) {
let state = Rc::new(RefCell::new(PointerCaptureState::default()));
let runtime = Application::new()
.window(
WindowBuilder::new()
.title("Pointer Capture")
.root(ChildRoot::new(PointerCaptureLeaf {
state: Rc::clone(&state),
recapture_on_move: false,
})),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id, state)
}
fn build_hover_transition_runtime() -> (
Runtime,
sui_core::WindowId,
Rc<RefCell<HoverTransitionState>>,
Rc<RefCell<HoverTransitionState>>,
) {
let first = Rc::new(RefCell::new(HoverTransitionState::default()));
let second = Rc::new(RefCell::new(HoverTransitionState::default()));
let runtime =
Application::new()
.window(WindowBuilder::new().title("Hover transitions").root(
HoverTransitionRoot::new(Rc::clone(&first), Rc::clone(&second)),
))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id, first, second)
}
fn build_wake_runtime() -> (Runtime, sui_core::WindowId, Rc<RefCell<WakeState>>) {
let state = Rc::new(RefCell::new(WakeState::default()));
let runtime = Application::new()
.window(
WindowBuilder::new()
.title("Wake")
.root(ChildRoot::new(WakeLeaf {
state: Rc::clone(&state),
})),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id, state)
}
fn build_animation_wake_runtime(
request_twice: bool,
) -> (Runtime, sui_core::WindowId, Rc<RefCell<AnimationWakeState>>) {
let state = Rc::new(RefCell::new(AnimationWakeState {
request_twice,
..AnimationWakeState::default()
}));
let runtime = Application::new()
.window(
WindowBuilder::new()
.title("Animation Wake")
.root(ChildRoot::new(AnimationWakeLeaf {
state: Rc::clone(&state),
})),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id, state)
}
fn build_removable_animation_runtime() -> (Runtime, sui_core::WindowId) {
let state = Rc::new(RefCell::new(AnimationWakeState::default()));
let runtime = Application::new()
.window(WindowBuilder::new().title("Removable Animation").root(
RemovableAnimationRoot {
child: Some(SingleChild::new(AnimationWakeLeaf { state })),
},
))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id)
}
fn build_text_runtime() -> (Runtime, sui_core::WindowId) {
let runtime = Application::new()
.window(
WindowBuilder::new()
.title("Text")
.root(PaintedChildRoot::new(TextImeLeaf {
layout: RefCell::new(None),
})),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
(runtime, window_id)
}
#[test]
fn runtime_exposes_retained_widget_graph() {
let (mut runtime, window_id, _, _) = build_runtime();
let output = runtime.render(window_id).unwrap();
let graph = runtime.widget_graph(window_id).unwrap();
assert_eq!(graph.nodes.len(), 2);
assert_eq!(graph.nodes[0].id, graph.root);
assert_eq!(graph.nodes[0].stack_host, graph.root);
assert!(graph.nodes[0].is_stack_host);
assert_eq!(graph_child(&graph).parent, Some(graph.root));
assert_eq!(graph_child(&graph).stack_host, graph.root);
assert!(!graph_child(&graph).is_stack_surface);
assert_eq!(graph.stack_hosts.len(), 1);
assert_eq!(graph.stack_hosts[0].host, graph.root);
assert!(graph.stack_hosts[0].surfaces.is_empty());
assert!(graph_child(&graph).accepts_focus);
assert_eq!(
graph_child(&graph).geometry.layout_bounds,
graph_child(&graph).bounds
);
assert_eq!(
graph_child(&graph).geometry.input_bounds,
graph_child(&graph).geometry.layout_bounds
);
assert_eq!(
graph_child(&graph).geometry.paint_bounds,
graph_child(&graph).geometry.layout_bounds
);
assert_eq!(output.frame.viewport, Size::new(320.0, 180.0));
assert_eq!(output.frame.surface_size, Size::new(320.0, 180.0));
assert_eq!(output.frame.scale_factor, 1.0);
}
#[test]
fn synthetic_semantic_activate_falls_back_to_pointer_routing() {
let (mut runtime, window_id, state) = build_semantics_action_runtime();
let _ = runtime.render(window_id).unwrap();
assert!(
runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Activate,
)
.unwrap()
);
let state = state.borrow();
assert_eq!(
state.actions,
vec![(SYNTHETIC_ACTION_ID, SemanticsActionRequest::Activate)]
);
assert_eq!(state.pointer_activations, 1);
}
#[test]
fn semantic_expand_and_collapse_use_idempotent_pointer_fallbacks() {
let (mut runtime, window_id, state) = build_semantics_action_runtime();
let _ = runtime.render(window_id).unwrap();
assert!(
runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Expand,
)
.unwrap()
);
assert!(state.borrow().expanded);
assert_eq!(state.borrow().pointer_activations, 1);
let _ = runtime.render(window_id).unwrap();
assert!(
runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Expand,
)
.unwrap()
);
assert_eq!(state.borrow().pointer_activations, 1);
assert!(
runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Collapse,
)
.unwrap()
);
assert!(!state.borrow().expanded);
assert_eq!(state.borrow().pointer_activations, 2);
}
#[test]
fn synthetic_semantic_focus_targets_graph_owner_and_retains_semantic_identity() {
let (mut runtime, window_id, state) = build_semantics_action_runtime();
let first = runtime.render(window_id).unwrap();
let owner_id = first
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("semantic action owner"))
.unwrap()
.id;
assert!(
runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Focus,
)
.unwrap()
);
assert_eq!(runtime.focused_widget(window_id).unwrap(), Some(owner_id));
let focused = runtime.render(window_id).unwrap();
assert!(
focused
.semantics
.iter()
.find(|node| node.id == SYNTHETIC_ACTION_ID)
.unwrap()
.state
.focused
);
assert_eq!(
state.borrow().actions,
vec![(SYNTHETIC_ACTION_ID, SemanticsActionRequest::Focus)]
);
let mut pointer = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 32.0));
pointer.button = Some(PointerButton::Primary);
pointer.buttons.insert(PointerButton::Primary);
runtime
.handle_event(window_id, Event::Pointer(pointer))
.unwrap();
let pointer_focused = runtime.render(window_id).unwrap();
assert!(
pointer_focused
.semantics
.iter()
.find(|node| node.id == owner_id)
.unwrap()
.state
.focused
);
assert!(
!pointer_focused
.semantics
.iter()
.find(|node| node.id == SYNTHETIC_ACTION_ID)
.unwrap()
.state
.focused
);
}
#[test]
fn semantic_blur_only_clears_the_current_semantic_focus_target() {
let (mut runtime, window_id, _state) = build_semantics_action_runtime();
let _ = runtime.render(window_id).unwrap();
assert!(
!runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Blur,
)
.unwrap()
);
assert!(
runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Focus,
)
.unwrap()
);
assert!(
runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Blur,
)
.unwrap()
);
assert_eq!(runtime.focused_widget(window_id).unwrap(), None);
}
#[test]
fn semantic_focus_rejects_an_unhandled_target_without_a_focusable_owner() {
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.title("Unfocusable Semantic Action")
.root(ChildRoot::new(UnfocusableSemanticLeaf)),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let output = runtime.render(window_id).unwrap();
let target = output
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("unfocusable semantic node"))
.unwrap()
.id;
assert!(
!runtime
.handle_semantics_action(window_id, target, SemanticsActionRequest::Focus,)
.unwrap()
);
assert_eq!(runtime.focused_widget(window_id).unwrap(), None);
assert!(
!runtime
.render(window_id)
.unwrap()
.semantics
.iter()
.find(|node| node.id == target)
.unwrap()
.state
.focused
);
}
#[test]
fn stale_disabled_and_unadvertised_semantic_actions_are_rejected() {
let (mut stale_runtime, stale_window_id, stale_state) = build_semantics_action_runtime();
let _ = stale_runtime.render(stale_window_id).unwrap();
assert!(
!stale_runtime
.handle_semantics_action(
stale_window_id,
WidgetId::new(u64::MAX - 2),
SemanticsActionRequest::Activate,
)
.unwrap()
);
assert!(
!stale_runtime
.handle_semantics_action(
stale_window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Increment,
)
.unwrap()
);
assert!(stale_state.borrow().actions.is_empty());
let (mut disabled_runtime, disabled_window_id, disabled_state) =
build_semantics_action_runtime();
disabled_state.borrow_mut().disabled = true;
let _ = disabled_runtime.render(disabled_window_id).unwrap();
assert!(
!disabled_runtime
.handle_semantics_action(
disabled_window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Activate,
)
.unwrap()
);
assert!(disabled_state.borrow().actions.is_empty());
}
#[test]
fn semantic_action_payload_is_typed_and_unsupported_actions_are_rejected() {
let (mut runtime, window_id, state) = build_semantics_action_runtime();
let _ = runtime.render(window_id).unwrap();
let set_value_handled = runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::SetValue(SemanticsValue::Text("forty two".into())),
)
.unwrap();
assert!(
set_value_handled,
"state after SetValue: {:?}; semantics: {:?}; graph: {:?}",
state.borrow(),
runtime.semantics(window_id).unwrap(),
runtime.widget_graph(window_id).unwrap()
);
assert!(
runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::InsertText("hello".into()),
)
.unwrap()
);
assert!(
!runtime
.handle_semantics_action(
window_id,
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::Increment,
)
.unwrap()
);
assert_eq!(
state.borrow().actions,
vec![
(
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::SetValue(SemanticsValue::Text("forty two".into())),
),
(
SYNTHETIC_ACTION_ID,
SemanticsActionRequest::InsertText("hello".into()),
),
]
);
}
#[test]
fn render_output_is_send_sync() {
fn assert_send_sync<T: Send + Sync>() {}
assert_send_sync::<RenderOutput>();
}
#[test]
fn widget_graph_visits_logical_children_even_when_paint_is_virtualized() {
let paint_state = Rc::new(RefCell::new(VirtualizedPaintState::default()));
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.title("Virtualized")
.root(VirtualizedLogicalRoot::new(4, 2, Rc::clone(&paint_state))),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
let graph = runtime.widget_graph(window_id).unwrap();
let root = graph
.nodes
.iter()
.find(|node| node.id == graph.root)
.unwrap();
assert_eq!(root.children.len(), 4);
assert_eq!(graph.nodes.len(), 5);
assert_eq!(paint_state.borrow().painted, vec![0, 1]);
}
#[test]
fn worker_owned_snapshot_state_reenters_runtime_without_widget_send_sync() {
let local = Rc::new(RefCell::new(ThreadedSnapshotState::default()));
let inbox = Arc::new(Mutex::new(VecDeque::new()));
let mut runtime =
Application::new()
.window(WindowBuilder::new().title("Threaded Snapshot").root(
ThreadedSnapshotRoot {
local: Rc::clone(&local),
inbox: Arc::clone(&inbox),
},
))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
runtime
.handle_event(
window_id,
Event::Custom(CustomEvent::new("arm-threaded-snapshot")),
)
.unwrap();
let async_token = local.borrow().async_token.unwrap();
let worker_inbox = Arc::clone(&inbox);
std::thread::spawn(move || {
worker_inbox
.lock()
.unwrap()
.push_back("worker-ready".to_string());
})
.join()
.unwrap();
assert!(runtime.wake_async(window_id, async_token).unwrap());
for (ready_window, event) in runtime.drain_ready_events() {
runtime.handle_event(ready_window, event).unwrap();
}
assert_eq!(local.borrow().latest.as_deref(), Some("worker-ready"));
assert!(runtime.needs_render(window_id).unwrap());
let _ = runtime.render(window_id).unwrap();
assert_eq!(local.borrow().paints, 2);
}
struct EventPoster {
log: Rc<RefCell<Vec<String>>>,
}
impl Widget for EventPoster {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if let Event::Custom(custom) = event {
self.log.borrow_mut().push(custom.kind.clone());
if custom.kind == "posted-trigger" {
ctx.post_event(
ctx.widget_id(),
Event::Custom(CustomEvent::new("posted-response")),
);
}
}
}
}
#[test]
fn posted_events_are_delivered_after_the_current_dispatch() {
let log = Rc::new(RefCell::new(Vec::new()));
let mut runtime = Application::new()
.window(WindowBuilder::new().title("Posted").root(EventPoster {
log: Rc::clone(&log),
}))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
runtime
.handle_event(window_id, Event::Custom(CustomEvent::new("posted-trigger")))
.unwrap();
assert_eq!(
log.borrow().as_slice(),
["posted-trigger".to_string(), "posted-response".to_string()]
);
}
#[test]
fn runtime_clipboard_is_shared_with_window_event_contexts() {
let mut runtime = Application::new()
.window(WindowBuilder::new().title("Clipboard").root(FocusLeaf {
counters: Rc::new(RefCell::new(Counters::default())),
}))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
runtime.clipboard().set_text("shared");
assert_eq!(runtime.clipboard().text().as_deref(), Some("shared"));
runtime.set_clipboard_backend(sui_core::LocalClipboardBackend::new());
assert_eq!(runtime.clipboard().text(), None);
}
#[test]
fn explicit_paint_boundary_direct_child_remains_a_stack_surface() {
let (mut runtime, window_id, _, _) = build_cached_move_runtime();
let _ = runtime.render(window_id).unwrap();
let graph = runtime.widget_graph(window_id).unwrap();
let child = graph_child(&graph);
assert!(child.is_stack_surface);
assert_eq!(graph.stack_hosts.len(), 1);
assert_eq!(graph.stack_hosts[0].host, graph.root);
assert_eq!(graph.stack_hosts[0].surfaces, vec![child.id]);
}
#[test]
fn non_hit_test_stack_surface_allows_underlying_pointer_target() {
let pointer_downs = Rc::new(RefCell::new(0));
let runtime = Application::new()
.window(
WindowBuilder::new()
.title("Overlay pass-through")
.root(OverlayPassThroughRoot::new(Rc::clone(&pointer_downs))),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let mut runtime = runtime;
let output = runtime.render(window_id).unwrap();
let mut overlay_hit_test = None;
output.frame.scene.visit_layers(&mut |layer| {
if layer.descriptor.composition_mode == LayerCompositionMode::Overlay {
overlay_hit_test = Some(layer.descriptor.hit_test);
}
});
assert_eq!(overlay_hit_test, Some(false));
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 36.0));
down.pointer_id = 1;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
assert_eq!(*pointer_downs.borrow(), 1);
}
#[test]
fn hit_test_stack_surface_targets_deepest_child() {
let pointer_downs = Rc::new(RefCell::new(0));
let runtime = Application::new()
.window(
WindowBuilder::new()
.title("Overlay child hit")
.root(HitTestOverlayRoot::new(Rc::clone(&pointer_downs))),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let mut runtime = runtime;
let output = runtime.render(window_id).unwrap();
let mut effect_hit_test = None;
output.frame.scene.visit_layers(&mut |layer| {
if layer.descriptor.composition_mode == LayerCompositionMode::Effect {
effect_hit_test = Some(layer.descriptor.hit_test);
}
});
assert_eq!(effect_hit_test, Some(true));
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(80.0, 60.0));
down.pointer_id = 1;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
assert_eq!(*pointer_downs.borrow(), 1);
}
#[test]
fn runtime_reports_surface_size_and_scale_factor_for_hidpi_windows() {
let (mut runtime, window_id, _, _) = build_runtime();
runtime
.handle_event(
window_id,
Event::Window(WindowEvent::ScaleFactorChanged {
scale_factor: 2.0,
raw_dpi: Some(192.0),
suggested_size: Some(Size::new(320.0, 180.0)),
}),
)
.unwrap();
let output = runtime.render(window_id).unwrap();
assert_eq!(output.frame.viewport, Size::new(320.0, 180.0));
assert_eq!(output.frame.surface_size, Size::new(640.0, 360.0));
assert_eq!(output.frame.scale_factor, 2.0);
}
#[test]
fn runtime_delivers_external_file_events_without_changing_window_geometry() {
let events = Rc::new(RefCell::new(Vec::new()));
let mut runtime =
Application::new()
.window(WindowBuilder::new().title("External file events").root(
WindowEventRecorder {
events: Rc::clone(&events),
},
))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let before = runtime.render(window_id).unwrap().frame;
let path = PathBuf::from(r"C:\workspace\agent.json");
for event in [
WindowEvent::ExternalFileHovered(path.clone()),
WindowEvent::ExternalFileDropped(path.clone()),
WindowEvent::ExternalFileHoverCancelled,
] {
runtime
.handle_event(window_id, Event::Window(event))
.unwrap();
}
assert_eq!(
events.borrow().as_slice(),
&[
WindowEvent::ExternalFileHovered(path.clone()),
WindowEvent::ExternalFileDropped(path),
WindowEvent::ExternalFileHoverCancelled,
]
);
let after = runtime.render(window_id).unwrap().frame;
assert_eq!(after.viewport, before.viewport);
assert_eq!(after.surface_size, before.surface_size);
assert_eq!(after.scale_factor, before.scale_factor);
}
#[test]
fn runtime_attaches_registered_fonts_to_render_output() {
let (mut runtime, window_id, _, _) = build_runtime();
let handle = FontHandle::new(33);
runtime
.register_font(handle, RegisteredFont::from_bytes(vec![0, 1, 2, 3]))
.unwrap();
let output = runtime.render(window_id).unwrap();
assert!(output.frame.font_registry.contains(handle));
}
#[test]
fn runtime_attaches_registered_images_to_render_output() {
let (mut runtime, window_id, _, _) = build_runtime();
let handle = ImageHandle::new(7);
runtime
.register_image(
handle,
RegisteredImage::from_rgba8(1, 1, vec![255, 0, 0, 255]).unwrap(),
)
.unwrap();
let output = runtime.render(window_id).unwrap();
assert!(output.frame.image_registry.contains(handle));
}
#[test]
fn paint_registered_external_images_are_included_in_render_output() {
struct ExternalImageLeaf {
handle: ImageHandle,
}
impl Widget for ExternalImageLeaf {
fn paint(&self, ctx: &mut PaintCtx) {
ctx.register_external_image(
self.handle,
RegisteredExternalImage::new(640, 360).unwrap(),
);
ctx.draw_image(ctx.bounds(), self.handle);
}
}
let handle = ImageHandle::new(71);
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.title("External image")
.root(ExternalImageLeaf { handle }),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let output = runtime.render(window_id).unwrap();
assert_eq!(
output.frame.image_registry.dimensions(handle),
Some((640, 360))
);
assert!(output.frame.image_registry.get(handle).is_none());
assert!(output.frame.image_registry.get_external(handle).is_some());
}
#[test]
fn runtime_attaches_registered_svg_images_to_render_output() {
let (mut runtime, window_id, _, _) = build_runtime();
let handle = ImageHandle::new(41);
let svg = br##"<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 4 4"><rect width="4" height="4" fill="#27B7C8"/></svg>"##;
runtime
.register_svg_image_at_size_with_handle(handle, 16, 16, svg)
.unwrap();
let output = runtime.render(window_id).unwrap();
let image = output.frame.image_registry.get(handle).unwrap();
assert_eq!(image.width(), 16);
assert_eq!(image.height(), 16);
assert!(image.bytes().chunks_exact(4).any(|pixel| pixel[3] > 0));
}
#[test]
fn semantics_only_invalidation_skips_repaint() {
let (mut runtime, window_id, root_counters, leaf_counters) = build_runtime();
let _ = runtime.render(window_id).unwrap();
let root_paint_before = root_counters.borrow().paint;
let leaf_paint_before = leaf_counters.borrow().paint;
runtime
.handle_event(window_id, Event::Custom(CustomEvent::new("semantics-only")))
.unwrap();
assert_eq!(
runtime.schedule(window_id).unwrap(),
FrameSchedule {
semantics: true,
..FrameSchedule::default()
}
);
let _ = runtime.render(window_id).unwrap();
assert_eq!(root_counters.borrow().paint, root_paint_before);
assert_eq!(leaf_counters.borrow().paint, leaf_paint_before);
assert!(root_counters.borrow().semantics >= 2);
}
#[test]
fn ordinary_widgets_flatten_scene_output_into_root() {
let (mut runtime, window_id, _, _) = build_runtime();
let output = runtime.render(window_id).unwrap();
let leaf_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
assert!(!scene_has_layer_for(&output.frame.scene, leaf_id));
}
#[test]
fn explicit_paint_boundary_widgets_emit_layers() {
let (mut runtime, window_id, _, _) = build_cached_move_runtime();
let output = runtime.render(window_id).unwrap();
let layer_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
assert!(scene_has_layer_for(&output.frame.scene, layer_id));
}
#[test]
fn flat_widgets_preserve_paint_bounds_larger_than_layout_bounds() {
let (mut runtime, window_id) = build_overpaint_runtime();
let _ = runtime.render(window_id).unwrap();
let graph = runtime.widget_graph(window_id).unwrap();
let child = graph_child(&graph);
assert_eq!(child.bounds, Rect::new(32.0, 24.0, 120.0, 40.0));
assert_eq!(child.geometry.paint_bounds, child.bounds.inflate(6.0, 4.0));
}
#[test]
fn paint_invalidation_repaints_nearest_boundary_root_for_flat_child() {
let (mut runtime, window_id, root_counters, leaf_counters) = build_runtime();
let _ = runtime.render(window_id).unwrap();
let leaf_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
let root_paint_before = root_counters.borrow().paint;
let leaf_paint_before = leaf_counters.borrow().paint;
let mut pointer = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
pointer.button = Some(PointerButton::Primary);
pointer.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(pointer))
.unwrap();
let output = runtime.render(window_id).unwrap();
assert_eq!(root_counters.borrow().paint, root_paint_before + 1);
assert_eq!(leaf_counters.borrow().paint, leaf_paint_before + 1);
assert!(!scene_has_layer_for(&output.frame.scene, leaf_id));
assert!(output.frame.layer_updates.is_empty());
}
#[test]
fn cached_layer_translation_updates_scene_without_repaint() {
let (mut runtime, window_id, root_counters, leaf_counters) = build_cached_move_runtime();
let first = runtime.render(window_id).unwrap();
let first_graph = runtime.widget_graph(window_id).unwrap();
let initial_graph_bounds = graph_child(&first_graph).geometry.paint_bounds;
let layer_id = graph_child(&first_graph).id;
let root_paint_before = root_counters.borrow().paint;
let leaf_paint_before = leaf_counters.borrow().paint;
let initial_bounds = first
.frame
.scene
.commands()
.iter()
.find_map(|command| match command {
SceneCommand::Layer(layer) if layer.widget_id() == layer_id => Some(layer.bounds()),
_ => None,
})
.expect("cached layer present before translation");
runtime
.handle_event(window_id, Event::Custom(CustomEvent::new("shift-cached")))
.unwrap();
let second = runtime.render(window_id).unwrap();
assert_eq!(root_counters.borrow().paint, root_paint_before);
assert_eq!(leaf_counters.borrow().paint, leaf_paint_before);
assert_eq!(second.frame.layer_updates.len(), 1);
assert_eq!(second.frame.layer_updates[0].owner, layer_id);
assert_eq!(
second.frame.layer_updates[0].kind,
SceneLayerUpdateKind::Transform
);
let translated_bounds = second
.frame
.scene
.commands()
.iter()
.find_map(|command| match command {
SceneCommand::Layer(layer) if layer.widget_id() == layer_id => Some(layer.bounds()),
_ => None,
})
.expect("cached layer present after translation");
assert_eq!(translated_bounds.x(), initial_bounds.x() + 48.0);
assert_eq!(translated_bounds.y(), initial_bounds.y());
let translated_graph_bounds = graph_child(&runtime.widget_graph(window_id).unwrap())
.geometry
.paint_bounds;
assert_eq!(
translated_graph_bounds,
initial_graph_bounds.translate(Vector::new(48.0, 0.0))
);
}
#[test]
fn composition_only_translation_keeps_ancestor_paint_bounds_conservative() {
let root_counters = Rc::new(RefCell::new(Counters::default()));
let leaf_counters = Rc::new(RefCell::new(Counters::default()));
let presentation = Rc::new(RefCell::new(CachedLayerPresentation::default()));
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.title("Bare cached move")
.root(CachedMoveRoot {
counters: Rc::clone(&root_counters),
child: SingleChild::new(CachedMoveLeaf {
counters: Rc::clone(&leaf_counters),
presentation: Rc::clone(&presentation),
}),
presentation,
offset_x: 0.0,
paint_background: false,
}),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
let initial_graph = runtime.widget_graph(window_id).unwrap();
let initial_root_paint = initial_graph.nodes[0].geometry.paint_bounds;
let initial_child_paint = graph_child(&initial_graph).geometry.paint_bounds;
let root_paint_before = root_counters.borrow().paint;
let leaf_paint_before = leaf_counters.borrow().paint;
runtime
.handle_event(window_id, Event::Custom(CustomEvent::new("shift-cached")))
.unwrap();
let _ = runtime.render(window_id).unwrap();
let shifted_graph = runtime.widget_graph(window_id).unwrap();
let shifted_child_paint = graph_child(&shifted_graph).geometry.paint_bounds;
assert_eq!(root_counters.borrow().paint, root_paint_before);
assert_eq!(leaf_counters.borrow().paint, leaf_paint_before);
assert_eq!(
shifted_graph.nodes[0].geometry.paint_bounds,
initial_root_paint.union(shifted_child_paint)
);
assert_eq!(
shifted_child_paint,
initial_child_paint.translate(Vector::new(48.0, 0.0))
);
}
#[test]
fn composition_only_translation_updates_focused_ime_rect() {
let root_counters = Rc::new(RefCell::new(Counters::default()));
let presentation = Rc::new(RefCell::new(CachedLayerPresentation::default()));
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.title("Cached IME move")
.root(CachedMoveRoot {
counters: Rc::clone(&root_counters),
child: SingleChild::new_with_paint_boundary(TextImeLeaf {
layout: RefCell::new(None),
}),
presentation,
offset_x: 0.0,
paint_background: true,
}),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
let mut pointer = PointerEvent::new(PointerEventKind::Down, Point::new(40.0, 40.0));
pointer.button = Some(PointerButton::Primary);
pointer.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(pointer))
.unwrap();
let focused = runtime.render(window_id).unwrap();
let initial_ime = focused
.ime_composition_rect
.expect("focused text layer should publish an IME rectangle");
let initial_paint_bounds = graph_child(&runtime.widget_graph(window_id).unwrap())
.geometry
.paint_bounds;
let root_paint_before = root_counters.borrow().paint;
runtime
.handle_event(window_id, Event::Custom(CustomEvent::new("shift-cached")))
.unwrap();
let shifted = runtime.render(window_id).unwrap();
assert_eq!(root_counters.borrow().paint, root_paint_before);
assert_eq!(
shifted.ime_composition_rect,
Some(initial_ime.translate(Vector::new(48.0, 0.0)))
);
assert_eq!(
graph_child(&runtime.widget_graph(window_id).unwrap())
.geometry
.paint_bounds,
initial_paint_bounds.translate(Vector::new(48.0, 0.0))
);
assert!(
shifted
.frame
.layer_updates
.iter()
.any(|update| { update.kind == SceneLayerUpdateKind::Transform })
);
}
#[test]
fn explicit_boundary_layer_property_translation_marks_transform_without_content_rebuild() {
let (mut runtime, window_id, root_counters, leaf_counters) = build_cached_move_runtime();
let first = runtime.render(window_id).unwrap();
let layer_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
let root_paint_before = root_counters.borrow().paint;
let leaf_paint_before = leaf_counters.borrow().paint;
let initial_layer = first
.frame
.scene
.commands()
.iter()
.find_map(|command| match command {
SceneCommand::Layer(layer) if layer.widget_id() == layer_id => Some(layer.clone()),
_ => None,
})
.expect("cached layer present before property translation");
runtime
.handle_event(
window_id,
Event::Custom(CustomEvent::new("nudge-cached-layer-property")),
)
.unwrap();
let second = runtime.render(window_id).unwrap();
let updated_layer = second
.frame
.scene
.commands()
.iter()
.find_map(|command| match command {
SceneCommand::Layer(layer) if layer.widget_id() == layer_id => Some(layer.clone()),
_ => None,
})
.expect("cached layer present after property translation");
assert_eq!(root_counters.borrow().paint, root_paint_before);
assert_eq!(leaf_counters.borrow().paint, leaf_paint_before);
assert_eq!(second.frame.layer_updates.len(), 1);
assert_eq!(second.frame.layer_updates[0].owner, layer_id);
assert_eq!(
second.frame.layer_updates[0].kind,
SceneLayerUpdateKind::Transform
);
assert_eq!(updated_layer.bounds(), initial_layer.bounds());
assert_eq!(
updated_layer.descriptor.properties.translation,
Vector::new(18.0, 0.0)
);
assert_eq!(updated_layer.descriptor.properties.opacity, 1.0);
}
#[test]
fn explicit_boundary_layer_opacity_marks_effect_without_content_rebuild() {
let (mut runtime, window_id, root_counters, leaf_counters) = build_cached_move_runtime();
let _ = runtime.render(window_id).unwrap();
let layer_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
let root_paint_before = root_counters.borrow().paint;
let leaf_paint_before = leaf_counters.borrow().paint;
runtime
.handle_event(
window_id,
Event::Custom(CustomEvent::new("fade-cached-layer")),
)
.unwrap();
let second = runtime.render(window_id).unwrap();
let updated_layer = second
.frame
.scene
.commands()
.iter()
.find_map(|command| match command {
SceneCommand::Layer(layer) if layer.widget_id() == layer_id => Some(layer.clone()),
_ => None,
})
.expect("cached layer present after opacity update");
assert_eq!(root_counters.borrow().paint, root_paint_before);
assert_eq!(leaf_counters.borrow().paint, leaf_paint_before);
assert_eq!(second.frame.layer_updates.len(), 1);
assert_eq!(second.frame.layer_updates[0].owner, layer_id);
assert_eq!(
second.frame.layer_updates[0].kind,
SceneLayerUpdateKind::Effect
);
assert_eq!(
updated_layer.descriptor.properties.translation,
Vector::ZERO
);
assert_eq!(updated_layer.descriptor.properties.opacity, 0.5);
}
#[test]
fn direct_flat_child_translation_repaints_nearest_boundary_root() {
let (mut runtime, window_id, root_counters, leaf_counters) = build_direct_move_runtime();
let first = runtime.render(window_id).unwrap();
let layer_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
let root_paint_before = root_counters.borrow().paint;
let leaf_paint_before = leaf_counters.borrow().paint;
let initial_rect = first
.frame
.scene
.commands()
.iter()
.find_map(|command| match command {
SceneCommand::FillRect { rect, .. }
if *rect != Rect::new(0.0, 0.0, 320.0, 180.0) =>
{
Some(*rect)
}
_ => None,
})
.expect("flat child fill present before translation");
runtime
.handle_event(window_id, Event::Custom(CustomEvent::new("shift-direct")))
.unwrap();
let second = runtime.render(window_id).unwrap();
assert_eq!(root_counters.borrow().paint, root_paint_before + 1);
assert_eq!(leaf_counters.borrow().paint, leaf_paint_before + 1);
assert!(!scene_has_layer_for(&second.frame.scene, layer_id));
assert!(second.frame.layer_updates.is_empty());
let translated_rect = second
.frame
.scene
.commands()
.iter()
.find_map(|command| match command {
SceneCommand::FillRect { rect, .. }
if *rect != Rect::new(0.0, 0.0, 320.0, 180.0) =>
{
Some(*rect)
}
_ => None,
})
.expect("flat child fill present after translation");
assert_eq!(translated_rect.x(), initial_rect.x() + 36.0);
assert_eq!(translated_rect.y(), initial_rect.y());
}
#[test]
fn semantics_attach_to_the_nearest_ancestor_node() {
let root_counters = Rc::new(RefCell::new(Counters::default()));
let leaf_counters = Rc::new(RefCell::new(Counters::default()));
let mut runtime = Application::new()
.window(WindowBuilder::new().title("Test").root(TestRoot {
counters: Rc::clone(&root_counters),
child: SingleChild::new(ChildRoot::new(FocusLeaf {
counters: Rc::clone(&leaf_counters),
})),
}))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let output = runtime.render(window_id).unwrap();
let root_id = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Window)
.map(|node| node.id)
.unwrap();
let leaf = output
.semantics
.iter()
.find(|node| node.role == SemanticsRole::Button)
.unwrap();
assert_eq!(leaf.parent, Some(root_id));
}
#[test]
fn tab_traversal_moves_focus_between_focusable_widgets() {
let (mut runtime, window_id, first_counters, second_counters) =
build_focus_traversal_runtime();
let _ = runtime.render(window_id).unwrap();
let graph = runtime.widget_graph(window_id).unwrap();
let first_id = graph.nodes[1].id;
let second_id = graph.nodes[2].id;
let mut pointer = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
pointer.button = Some(PointerButton::Primary);
pointer.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(pointer))
.unwrap();
assert_eq!(
runtime.focus_state(window_id).unwrap(),
FocusState {
focused_widget: Some(first_id),
window_focused: true,
}
);
assert!(
runtime
.widget_graph(window_id)
.unwrap()
.nodes
.iter()
.find(|node| node.id == first_id)
.is_some_and(|node| node.focused)
);
runtime
.handle_event(
window_id,
Event::Keyboard(KeyboardEvent::new("Tab", KeyState::Pressed)),
)
.unwrap();
assert_eq!(first_counters.borrow().keyboard, 1);
assert_eq!(
runtime.focus_state(window_id).unwrap(),
FocusState {
focused_widget: Some(second_id),
window_focused: true,
}
);
assert!(
runtime
.widget_graph(window_id)
.unwrap()
.nodes
.iter()
.find(|node| node.id == second_id)
.is_some_and(|node| node.focused)
);
let output = runtime.render(window_id).unwrap();
assert!(
output
.semantics
.iter()
.find(|node| node.id == second_id)
.is_some_and(|node| node.state.focused)
);
let mut reverse_tab = KeyboardEvent::new("Tab", KeyState::Pressed);
reverse_tab.modifiers.shift = true;
runtime
.handle_event(window_id, Event::Keyboard(reverse_tab))
.unwrap();
assert_eq!(second_counters.borrow().keyboard, 1);
assert_eq!(
runtime.focus_state(window_id).unwrap(),
FocusState {
focused_widget: Some(first_id),
window_focused: true,
}
);
assert!(
runtime
.widget_graph(window_id)
.unwrap()
.nodes
.iter()
.find(|node| node.id == first_id)
.is_some_and(|node| node.focused)
);
}
#[test]
fn managed_overlay_traps_restores_and_traces_focus_and_dismissal() {
let open = Rc::new(RefCell::new(false));
let dismissals = Rc::new(RefCell::new(Vec::new()));
let mut runtime = Application::new()
.window(WindowBuilder::new().title("Managed overlay").root(
ManagedOverlayTestRoot::new(Rc::clone(&open), Rc::clone(&dismissals)),
))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let initial = runtime.render(window_id).unwrap();
assert!(
runtime
.overlay_snapshot(window_id)
.unwrap()
.overlays
.is_empty()
);
let graph = runtime.widget_graph(window_id).unwrap();
let root_id = graph.nodes[0].id;
let background_id = graph
.nodes
.iter()
.find(|node| node.parent == Some(root_id) && node.accepts_focus)
.unwrap()
.id;
assert!(
initial
.semantics
.iter()
.any(|node| node.id == background_id)
);
assert!(
runtime
.handle_semantics_action(window_id, background_id, SemanticsActionRequest::Focus,)
.unwrap()
);
assert_eq!(
runtime.focused_widget(window_id).unwrap(),
Some(background_id)
);
runtime
.handle_event(
window_id,
Event::Custom(CustomEvent::new("open-managed-overlay")),
)
.unwrap();
let opened = runtime.render(window_id).unwrap();
let snapshot = runtime.overlay_snapshot(window_id).unwrap();
assert_eq!(snapshot.overlays.len(), 1);
assert_eq!(snapshot.active_modal, Some(snapshot.overlays[0].owner));
assert_eq!(snapshot.focus_trap, Some(snapshot.overlays[0].owner));
assert!(!opened.semantics.iter().any(|node| node.id == background_id));
assert!(
opened
.semantics
.iter()
.any(|node| { node.id == snapshot.overlays[0].owner && node.state.modal })
);
let first_overlay_focus = runtime.focused_widget(window_id).unwrap().unwrap();
assert_ne!(first_overlay_focus, background_id);
runtime
.handle_event(
window_id,
Event::Keyboard(KeyboardEvent::new("Tab", KeyState::Pressed)),
)
.unwrap();
let second_overlay_focus = runtime.focused_widget(window_id).unwrap().unwrap();
assert_ne!(second_overlay_focus, first_overlay_focus);
runtime
.handle_event(
window_id,
Event::Keyboard(KeyboardEvent::new("Tab", KeyState::Pressed)),
)
.unwrap();
assert_eq!(
runtime.focused_widget(window_id).unwrap(),
Some(first_overlay_focus)
);
runtime
.handle_event(
window_id,
Event::Keyboard(KeyboardEvent::new("Escape", KeyState::Pressed)),
)
.unwrap();
assert_eq!(
dismissals.borrow().as_slice(),
&[OverlayDismissReason::Escape]
);
let _ = runtime.render(window_id).unwrap();
assert!(
runtime
.overlay_snapshot(window_id)
.unwrap()
.overlays
.is_empty()
);
assert_eq!(
runtime.focused_widget(window_id).unwrap(),
Some(background_id)
);
let traces = runtime.take_overlay_traces(window_id).unwrap();
for expected in [
OverlayTraceKind::Opened,
OverlayTraceKind::FocusEntered,
OverlayTraceKind::DismissRequested,
OverlayTraceKind::Closed,
OverlayTraceKind::FocusRestored,
] {
assert!(traces.iter().any(|trace| trace.kind == expected));
}
}
#[test]
fn pointer_capture_routes_drag_events_until_pointer_up() {
let (mut runtime, window_id, state) = build_pointer_capture_runtime();
let _ = runtime.render(window_id).unwrap();
let child_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = 7;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
assert_eq!(
runtime.pointer_capture_target(window_id, 7).unwrap(),
Some(child_id)
);
let mut moved = PointerEvent::new(PointerEventKind::Move, Point::new(260.0, 140.0));
moved.pointer_id = 7;
moved.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(moved))
.unwrap();
let mut up = PointerEvent::new(PointerEventKind::Up, Point::new(260.0, 140.0));
up.pointer_id = 7;
up.button = Some(PointerButton::Primary);
runtime.handle_event(window_id, Event::Pointer(up)).unwrap();
assert_eq!(state.borrow().moves, 1);
assert_eq!(state.borrow().ups, 1);
assert_eq!(state.borrow().cancels, 0);
assert_eq!(runtime.pointer_capture_target(window_id, 7).unwrap(), None);
}
#[test]
fn window_focus_loss_cancels_all_pointer_captures_and_applies_cleanup_effects() {
let (mut runtime, window_id, state) = build_pointer_capture_runtime();
let _ = runtime.render(window_id).unwrap();
let child_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
for pointer_id in [31, 47] {
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = pointer_id;
down.pointer_kind = PointerKind::Touch;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
assert_eq!(
runtime
.pointer_capture_target(window_id, pointer_id)
.unwrap(),
Some(child_id)
);
}
runtime
.handle_event(window_id, Event::Window(WindowEvent::Focused(false)))
.unwrap();
assert_eq!(state.borrow().cancels, 2);
assert_eq!(state.borrow().cancel_followups, 2);
assert!(runtime.needs_render(window_id).unwrap());
for pointer_id in [31, 47] {
assert_eq!(
runtime
.pointer_capture_target(window_id, pointer_id)
.unwrap(),
None
);
}
}
#[test]
fn pointer_capture_transfer_cancels_displaced_owner_and_preserves_new_owner() {
let state = Rc::new(RefCell::new(PointerCaptureState::default()));
let mut runtime = Application::new()
.window(WindowBuilder::new().title("Pointer Capture Transfer").root(
PointerCaptureTransferRoot::new(PointerCaptureLeaf {
state: Rc::clone(&state),
recapture_on_move: false,
}),
))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
let graph = runtime.widget_graph(window_id).unwrap();
let root_id = graph.root;
let child_id = graph_child(&graph).id;
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = 17;
down.pointer_kind = PointerKind::Touch;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
assert_eq!(
runtime.pointer_capture_target(window_id, 17).unwrap(),
Some(child_id)
);
let mut moved = PointerEvent::new(PointerEventKind::Move, Point::new(48.0, 18.0));
moved.pointer_id = 17;
moved.pointer_kind = PointerKind::Touch;
moved.delta = Vector::new(0.0, -22.0);
moved.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(moved))
.unwrap();
assert_eq!(
runtime.pointer_capture_target(window_id, 17).unwrap(),
Some(root_id),
"the displaced owner's release request must not clear the new capture"
);
assert!(
runtime.needs_render(window_id).unwrap(),
"the displaced owner's invalidations must be applied"
);
let state = state.borrow();
assert_eq!(state.cancels, 1);
assert_eq!(state.cancel_followups, 1);
let cancel = state.last_cancel.as_ref().expect("cancel event recorded");
assert_eq!(cancel.pointer_id, 17);
assert_eq!(cancel.kind, PointerEventKind::Cancel);
assert_eq!(cancel.position, Point::new(48.0, 18.0));
assert_eq!(cancel.delta, Vector::ZERO);
assert_eq!(cancel.pointer_kind, PointerKind::Touch);
assert_eq!(cancel.button, None);
assert_eq!(cancel.buttons, PointerButtons::NONE);
assert_eq!(cancel.scroll_delta, None);
}
#[test]
fn pointer_capture_transfer_cancels_reentrant_intermediate_owner() {
let state = Rc::new(RefCell::new(ReentrantCaptureState::default()));
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.title("Reentrant Pointer Capture Transfer")
.root(ReentrantCaptureRoot::new(Rc::clone(&state))),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
let graph = runtime.widget_graph(window_id).unwrap();
let root_id = graph.root;
let source_id = graph.nodes[1].id;
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = 59;
down.pointer_kind = PointerKind::Touch;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
assert_eq!(
runtime.pointer_capture_target(window_id, 59).unwrap(),
Some(source_id)
);
let mut moved = PointerEvent::new(PointerEventKind::Move, Point::new(48.0, 18.0));
moved.pointer_id = 59;
moved.pointer_kind = PointerKind::Touch;
moved.delta = Vector::new(0.0, -22.0);
moved.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(moved))
.unwrap();
let state = state.borrow();
assert_eq!(state.source_cancels, 1);
assert_eq!(state.intermediate_captures, 1);
assert_eq!(state.intermediate_cancels, 1);
assert_eq!(
runtime.pointer_capture_target(window_id, 59).unwrap(),
Some(root_id),
"the original transfer target must win after intermediate cleanup"
);
}
#[test]
fn recapturing_pointer_for_same_owner_does_not_emit_cancel() {
let state = Rc::new(RefCell::new(PointerCaptureState::default()));
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.title("Pointer Recapture")
.root(ChildRoot::new(PointerCaptureLeaf {
state: Rc::clone(&state),
recapture_on_move: true,
})),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
let child_id = graph_child(&runtime.widget_graph(window_id).unwrap()).id;
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = 23;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
let mut moved = PointerEvent::new(PointerEventKind::Move, Point::new(80.0, 40.0));
moved.pointer_id = 23;
moved.delta = Vector::new(32.0, 0.0);
moved.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(moved))
.unwrap();
assert_eq!(state.borrow().cancels, 0);
assert_eq!(
runtime.pointer_capture_target(window_id, 23).unwrap(),
Some(child_id)
);
}
#[test]
fn active_drag_hit_tests_drop_target_while_source_keeps_pointer_capture() {
let state = Rc::new(RefCell::new(RuntimeDragState::default()));
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.title("Runtime Drag")
.root(RuntimeDragRoot::new(Rc::clone(&state))),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = 7;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
let mut moved = PointerEvent::new(PointerEventKind::Move, Point::new(188.0, 40.0));
moved.pointer_id = 7;
moved.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(moved))
.unwrap();
let mut up = PointerEvent::new(PointerEventKind::Up, Point::new(188.0, 40.0));
up.pointer_id = 7;
up.button = Some(PointerButton::Primary);
runtime.handle_event(window_id, Event::Pointer(up)).unwrap();
let state = state.borrow();
assert_eq!(state.source_moves, 1);
assert!(state.target_overs >= 1);
assert_eq!(state.drops, 1);
assert_eq!(state.ends, 1);
assert!(matches!(
state.outcome,
Some(DragOutcome::Dropped {
effect: DropEffect::Move,
..
})
));
}
#[test]
fn pointer_move_synthesizes_widget_leave_and_enter_transitions() {
let (mut runtime, window_id, first, second) = build_hover_transition_runtime();
let _ = runtime.render(window_id).unwrap();
runtime
.handle_event(
window_id,
Event::Pointer(PointerEvent::new(
PointerEventKind::Move,
Point::new(48.0, 40.0),
)),
)
.unwrap();
assert_eq!(
*first.borrow(),
HoverTransitionState {
enters: 1,
leaves: 0,
hovered: true,
}
);
assert_eq!(*second.borrow(), HoverTransitionState::default());
runtime
.handle_event(
window_id,
Event::Pointer(PointerEvent::new(
PointerEventKind::Move,
Point::new(280.0, 140.0),
)),
)
.unwrap();
assert_eq!(
*first.borrow(),
HoverTransitionState {
enters: 1,
leaves: 1,
hovered: false,
}
);
runtime
.handle_event(
window_id,
Event::Pointer(PointerEvent::new(
PointerEventKind::Move,
Point::new(188.0, 40.0),
)),
)
.unwrap();
assert_eq!(
*second.borrow(),
HoverTransitionState {
enters: 1,
leaves: 0,
hovered: true,
}
);
}
#[test]
fn timers_and_async_wakeups_reenter_runtime_with_registered_target() {
let (mut runtime, window_id, state) = build_wake_runtime();
let _ = runtime.render(window_id).unwrap();
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = 11;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
let async_token = state.borrow().async_token.unwrap();
let timer_token = state.borrow().timer_token.unwrap();
let scheduler = runtime.inspector_snapshot(window_id).unwrap().scheduler;
assert!(scheduler.timers.iter().any(|timer| {
timer.token == timer_token && timer.deadline == 3.0 && !timer.delivering
}));
assert!(
scheduler
.async_tasks
.iter()
.any(|task| { task.token == async_token && !task.pending_wake })
);
assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), Some(3.0));
assert!(runtime.wake_async(window_id, async_token).unwrap());
let ready = runtime.drain_ready_events();
assert_eq!(ready.len(), 1);
assert!(matches!(
ready[0],
(ready_window, Event::Wake(WakeEvent::Async { token, time }))
if ready_window == window_id && token == async_token && time == 0.0
));
for (ready_window, event) in ready {
runtime.handle_event(ready_window, event).unwrap();
}
assert_eq!(state.borrow().async_wakes, 1);
runtime.tick(3.0);
let ready = runtime.drain_ready_events();
assert_eq!(ready.len(), 1);
assert!(matches!(
ready[0],
(ready_window, Event::Wake(WakeEvent::Timer { token, time, deadline }))
if ready_window == window_id && token == timer_token && time == 3.0 && deadline == 3.0
));
for (ready_window, event) in ready {
runtime.handle_event(ready_window, event).unwrap();
}
assert_eq!(state.borrow().timer_wakes, 1);
assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), None);
}
#[test]
fn animation_frame_wakeups_reenter_runtime_with_registered_target() {
let (mut runtime, window_id, state) = build_animation_wake_runtime(false);
let _ = runtime.render(window_id).unwrap();
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = 12;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), Some(0.0));
let ready = runtime.drain_ready_events();
assert_eq!(ready.len(), 1);
assert!(matches!(
ready[0],
(
ready_window,
Event::Wake(WakeEvent::AnimationFrame {
time,
delta,
frame_index,
})
) if ready_window == window_id && time == 0.0 && delta == 0.0 && frame_index == 0
));
for (ready_window, event) in ready {
runtime.handle_event(ready_window, event).unwrap();
}
let state = state.borrow();
assert_eq!(state.animation_wakes, 1);
assert_eq!(state.last_animation_time, Some(0.0));
assert_eq!(state.last_animation_delta, Some(0.0));
assert_eq!(state.last_animation_frame_index, Some(0));
assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), None);
}
#[test]
fn animation_frame_wakeups_are_target_only_not_captured_by_ancestors() {
let state = Rc::new(RefCell::new(AnimationWakeState::default()));
let ancestor_wakes = Rc::new(RefCell::new(0usize));
let mut runtime = Application::new()
.window(WindowBuilder::new().title("Animation Capture").root(
AnimationWakeCapturingRoot {
child: SingleChild::new(AnimationWakeLeaf {
state: Rc::clone(&state),
}),
ancestor_wakes: Rc::clone(&ancestor_wakes),
},
))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let _ = runtime.render(window_id).unwrap();
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = 15;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
let ready = runtime.drain_ready_events();
assert_eq!(ready.len(), 1);
for (ready_window, event) in ready {
runtime.handle_event(ready_window, event).unwrap();
}
assert_eq!(state.borrow().animation_wakes, 1);
assert_eq!(*ancestor_wakes.borrow(), 0);
assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), None);
}
#[test]
fn repeated_animation_frame_requests_are_idempotent_for_the_same_widget() {
let (mut runtime, window_id, state) = build_animation_wake_runtime(true);
let _ = runtime.render(window_id).unwrap();
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = 13;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
let ready = runtime.drain_ready_events();
assert_eq!(ready.len(), 1);
for (ready_window, event) in ready {
runtime.handle_event(ready_window, event).unwrap();
}
assert_eq!(state.borrow().animation_wakes, 1);
assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), None);
}
#[test]
fn animated_widget_registration_is_cleaned_up_when_widget_disappears() {
let (mut runtime, window_id) = build_removable_animation_runtime();
let _ = runtime.render(window_id).unwrap();
let mut down = PointerEvent::new(PointerEventKind::Down, Point::new(48.0, 40.0));
down.pointer_id = 14;
down.button = Some(PointerButton::Primary);
down.buttons = PointerButtons::new(1);
runtime
.handle_event(window_id, Event::Pointer(down))
.unwrap();
assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), Some(0.0));
runtime
.handle_event(
window_id,
Event::Custom(CustomEvent::new("drop-animation-child")),
)
.unwrap();
let _ = runtime.render(window_id).unwrap();
assert_eq!(runtime.next_wakeup_time(window_id).unwrap(), None);
assert!(runtime.drain_ready_events().is_empty());
}
#[test]
fn initial_runtime_needs_render() {
let (runtime, window_id, _, _) = build_runtime();
assert!(runtime.needs_render(window_id).unwrap());
}
#[test]
fn runtime_render_populates_widget_count_diagnostics() {
let (mut runtime, window_id, _, _) = build_runtime();
let output = runtime.render(window_id).unwrap();
let graph = runtime.widget_graph(window_id).unwrap();
assert_eq!(output.diagnostics.widget_count, graph.nodes.len());
}
#[test]
fn inspector_snapshot_unifies_structure_routes_and_widget_diagnostics() {
let (mut runtime, window_id, _, _) = build_runtime();
runtime.set_inspector_tracing(window_id, true).unwrap();
runtime.render(window_id).unwrap();
runtime
.handle_event(
window_id,
Event::Pointer(PointerEvent::new(
PointerEventKind::Down,
Point::new(48.0, 40.0),
)),
)
.unwrap();
let snapshot = runtime.inspector_snapshot(window_id).unwrap();
assert_eq!(snapshot.title, "Test");
assert!(!snapshot.semantics.is_empty());
assert!(
snapshot
.widget_graph
.nodes
.iter()
.any(|node| node.widget_name.ends_with("TestRoot"))
);
assert!(snapshot.widget_diagnostics.iter().any(|diagnostics| {
diagnostics.widget_name.ends_with("TestRoot")
&& diagnostics
.entries
.iter()
.any(|entry| entry.name == "test state" && entry.value == "available")
}));
let route = snapshot.history.event_routes.last().unwrap();
assert_eq!(route.event_kind, "pointer");
assert!(route.steps.iter().any(|step| {
step.phase == EventRoutePhase::Capture || step.phase == EventRoutePhase::Target
}));
assert!(snapshot.scene.is_some());
}
struct ReactiveTextLeaf {
text: Signal<String>,
measures: Arc<AtomicUsize>,
}
impl Widget for ReactiveTextLeaf {
fn measure(&mut self, ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
let text = ctx.observe_with(&self.text, InvalidationKind::Text);
self.measures.fetch_add(1, Ordering::Relaxed);
constraints.clamp(Size::new(text.len() as f32 * 8.0, 24.0))
}
fn semantics(&self, ctx: &mut SemanticsCtx) {
let mut node = SemanticsNode::new(ctx.widget_id(), SemanticsRole::Text, ctx.bounds());
node.name = Some(self.text.get());
ctx.push(node);
}
}
#[test]
fn observable_change_targets_widget_and_reports_diagnostics() {
let text = Signal::named("status_text", "Ready".to_string());
let measures = Arc::new(AtomicUsize::new(0));
let mut runtime = Application::new()
.window(WindowBuilder::new().root(ReactiveTextLeaf {
text: text.clone(),
measures: Arc::clone(&measures),
}))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let wakes = Arc::new(AtomicUsize::new(0));
let wake_count = Arc::clone(&wakes);
runtime.set_external_waker(move || {
wake_count.fetch_add(1, Ordering::Relaxed);
});
let first = runtime.render(window_id).unwrap();
assert_eq!(measures.load(Ordering::Relaxed), 1);
assert_eq!(first.semantics[0].name.as_deref(), Some("Ready"));
assert!(text.set("Connecting".to_string()));
assert!(text.set("Connected".to_string()));
assert_eq!(wakes.load(Ordering::Relaxed), 1);
assert!(runtime.needs_render(window_id).unwrap());
let second = runtime.render(window_id).unwrap();
assert_eq!(measures.load(Ordering::Relaxed), 2);
assert_eq!(second.semantics[0].name.as_deref(), Some("Connected"));
let samples = second
.diagnostics
.reactive_invalidations
.iter()
.filter(|sample| {
sample.source_name == "status_text"
&& sample.kind == InvalidationKind::Text
&& sample.delivered
})
.collect::<Vec<_>>();
assert_eq!(samples.len(), 1);
assert_eq!(samples[0].version, 2);
}
static TEST_COMMAND: CommandKey<u32> = CommandKey::new("runtime.test.command");
struct CommandRoot {
commands: Arc<AtomicUsize>,
custom_events: Arc<AtomicUsize>,
}
impl Widget for CommandRoot {
fn event(&mut self, _ctx: &mut EventCtx, event: &Event) {
if matches!(event, Event::Custom(_)) {
self.custom_events.fetch_add(1, Ordering::Relaxed);
}
}
fn command(&mut self, ctx: &mut EventCtx, command: &Command<'_>) {
if command.get(TEST_COMMAND).is_some() {
self.commands.fetch_add(1, Ordering::Relaxed);
ctx.request_paint();
ctx.set_handled();
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 80.0))
}
}
struct WakeController(Arc<AtomicUsize>);
impl CommandController for WakeController {
fn wake(&mut self, _ctx: &mut CommandCtx) {
self.0.fetch_add(1, Ordering::Relaxed);
}
}
struct EventCommandRoot;
impl Widget for EventCommandRoot {
fn event(&mut self, ctx: &mut EventCtx, event: &Event) {
if matches!(event, Event::Custom(_)) {
ctx.command_sender().send_application(TEST_COMMAND, 41);
}
}
fn measure(&mut self, _ctx: &mut MeasureCtx, constraints: Constraints) -> Size {
constraints.clamp(Size::new(120.0, 80.0))
}
}
#[test]
fn scheduler_wake_invokes_controllers_without_synthesizing_a_root_event() {
let controller_wakes = Arc::new(AtomicUsize::new(0));
let custom_events = Arc::new(AtomicUsize::new(0));
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.controller(WakeController(Arc::clone(&controller_wakes)))
.root(CommandRoot {
commands: Arc::new(AtomicUsize::new(0)),
custom_events: Arc::clone(&custom_events),
}),
)
.build()
.unwrap();
runtime.command_sender().wake();
runtime.process_commands();
assert_eq!(controller_wakes.load(Ordering::Relaxed), 1);
assert_eq!(custom_events.load(Ordering::Relaxed), 0);
}
#[test]
fn widget_event_context_can_enqueue_an_application_command() {
let received = Arc::new(AtomicUsize::new(0));
let received_by_handler = Arc::clone(&received);
let mut runtime = Application::new()
.on_command(TEST_COMMAND, move |ctx, value| {
received_by_handler.store(*value as usize, Ordering::Relaxed);
ctx.set_handled();
})
.window(WindowBuilder::new().root(EventCommandRoot))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
runtime
.handle_event(
window_id,
Event::Custom(CustomEvent::new("runtime.test.enqueue-command")),
)
.unwrap();
assert_eq!(received.load(Ordering::Relaxed), 0);
runtime.process_commands();
assert_eq!(received.load(Ordering::Relaxed), 41);
}
#[test]
fn directed_commands_stop_when_handled_while_broadcast_reaches_all_subscribers() {
let first = Arc::new(AtomicUsize::new(0));
let second = Arc::new(AtomicUsize::new(0));
let first_handler = Arc::clone(&first);
let second_handler = Arc::clone(&second);
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.on_command(TEST_COMMAND, move |ctx, _| {
first_handler.fetch_add(1, Ordering::Relaxed);
ctx.set_handled();
})
.on_command(TEST_COMMAND, move |_, _| {
second_handler.fetch_add(1, Ordering::Relaxed);
})
.root(CommandRoot {
commands: Arc::new(AtomicUsize::new(0)),
custom_events: Arc::new(AtomicUsize::new(0)),
}),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let sender = runtime.command_sender();
sender.send_window(window_id, TEST_COMMAND, 1);
runtime.process_commands();
assert_eq!(first.load(Ordering::Relaxed), 1);
assert_eq!(second.load(Ordering::Relaxed), 0);
sender.broadcast_window(window_id, TEST_COMMAND, 2);
runtime.process_commands();
assert_eq!(first.load(Ordering::Relaxed), 2);
assert_eq!(second.load(Ordering::Relaxed), 1);
}
#[test]
fn application_broadcast_is_thread_safe_multicast_and_drops_removed_window_subscriptions() {
let application_count = Arc::new(AtomicUsize::new(0));
let first_window_count = Arc::new(AtomicUsize::new(0));
let second_window_count = Arc::new(AtomicUsize::new(0));
let application_handler = Arc::clone(&application_count);
let first_handler = Arc::clone(&first_window_count);
let second_handler = Arc::clone(&second_window_count);
let root = || CommandRoot {
commands: Arc::new(AtomicUsize::new(0)),
custom_events: Arc::new(AtomicUsize::new(0)),
};
let mut runtime = Application::new()
.on_command(TEST_COMMAND, move |_, _| {
application_handler.fetch_add(1, Ordering::Relaxed);
})
.window(
WindowBuilder::new()
.on_command(TEST_COMMAND, move |_, _| {
first_handler.fetch_add(1, Ordering::Relaxed);
})
.root(root()),
)
.window(
WindowBuilder::new()
.on_command(TEST_COMMAND, move |_, _| {
second_handler.fetch_add(1, Ordering::Relaxed);
})
.root(root()),
)
.build()
.unwrap();
let first_window = runtime.window_ids()[0];
let sender = runtime.command_sender();
let producer = std::thread::spawn(move || {
sender.broadcast_application(TEST_COMMAND, 1);
sender
});
let sender = producer.join().unwrap();
runtime.process_commands();
assert_eq!(application_count.load(Ordering::Relaxed), 1);
assert_eq!(first_window_count.load(Ordering::Relaxed), 1);
assert_eq!(second_window_count.load(Ordering::Relaxed), 1);
runtime.remove_window(first_window).unwrap();
sender.broadcast_application(TEST_COMMAND, 2);
runtime.process_commands();
assert_eq!(application_count.load(Ordering::Relaxed), 2);
assert_eq!(first_window_count.load(Ordering::Relaxed), 1);
assert_eq!(second_window_count.load(Ordering::Relaxed), 2);
}
#[test]
fn widget_commands_and_controller_invalidations_are_traced() {
let commands = Arc::new(AtomicUsize::new(0));
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.on_command(TEST_COMMAND, |ctx, _| {
ctx.request_window_with_reason(
InvalidationKind::Paint,
"test command changed presentation",
);
})
.root(CommandRoot {
commands: Arc::clone(&commands),
custom_events: Arc::new(AtomicUsize::new(0)),
}),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
runtime.render(window_id).unwrap();
let root_id = runtime.widget_graph(window_id).unwrap().root;
let sender = runtime.command_sender();
sender.send_widget(window_id, root_id, TEST_COMMAND, 1);
sender.send_widget(window_id, WidgetId::new(u64::MAX), TEST_COMMAND, 2);
sender.send_window(window_id, TEST_COMMAND, 3);
runtime.process_commands();
let output = runtime.render(window_id).unwrap();
assert_eq!(commands.load(Ordering::Relaxed), 1);
assert!(output.diagnostics.command_dispatches.iter().any(|sample| {
sample.name == TEST_COMMAND.name()
&& sample.payload_type == std::any::type_name::<u32>()
&& sample.delivered
}));
assert!(output.diagnostics.command_dispatches.iter().any(|sample| {
sample.name == TEST_COMMAND.name()
&& matches!(sample.target, CommandTarget::Widget { widget_id, .. } if widget_id == WidgetId::new(u64::MAX))
&& !sample.delivered
}));
assert!(output.diagnostics.invalidations.iter().any(|sample| {
sample.source == format!("command:{}", TEST_COMMAND.name())
&& sample.reason.as_deref() == Some("test command changed presentation")
}));
}
#[test]
fn focused_command_without_focus_is_dropped_instead_of_targeting_the_root() {
let commands = Arc::new(AtomicUsize::new(0));
let mut runtime = Application::new()
.window(WindowBuilder::new().root(CommandRoot {
commands: Arc::clone(&commands),
custom_events: Arc::new(AtomicUsize::new(0)),
}))
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
runtime.render(window_id).unwrap();
runtime
.command_sender()
.send_focused(window_id, TEST_COMMAND, 1);
runtime.process_commands();
let output = runtime.render(window_id).unwrap();
assert_eq!(commands.load(Ordering::Relaxed), 0);
assert!(output.diagnostics.command_dispatches.iter().any(|sample| {
sample.name == TEST_COMMAND.name()
&& sample.target == CommandTarget::FocusedWidget(window_id)
&& !sample.delivered
}));
}
#[test]
fn runtime_render_reports_ime_composition_rect_for_shaped_text_widgets() {
let (mut runtime, window_id) = build_text_runtime();
set_window_scene_statistics_detail_mode(window_id, SceneStatisticsDetailMode::Detailed);
let output = runtime.render(window_id).unwrap();
assert!(output.ime_composition_rect.is_some());
assert!(output.diagnostics.text_caches.runtime_layout.misses > 0);
assert!(!output.frame.scene.commands().is_empty());
let mut saw_shaped_text = false;
output.frame.scene.visit_commands(&mut |command| {
if matches!(command, sui_scene::SceneCommand::DrawShapedText(_)) {
saw_shaped_text = true;
}
});
assert!(saw_shaped_text);
}
#[test]
fn browser_back_clears_ime_focus_before_becoming_unhandled() {
let mut runtime = Application::new()
.window(
WindowBuilder::new()
.title("Browser Back IME")
.root(PaintedChildRoot::new(FocusedImeLeaf)),
)
.build()
.unwrap();
let window_id = runtime.window_ids()[0];
let initial = runtime.render(window_id).unwrap();
let text_input = initial
.semantics
.iter()
.find(|node| node.role == SemanticsRole::TextInput)
.expect("focused IME test input")
.id;
assert!(
runtime
.handle_semantics_action(window_id, text_input, SemanticsActionRequest::Focus)
.unwrap()
);
assert!(
runtime
.render(window_id)
.unwrap()
.ime_composition_rect
.is_some()
);
assert!(
runtime
.dispatch_event(
window_id,
Event::Keyboard(KeyboardEvent::new("BrowserBack", KeyState::Pressed)),
)
.unwrap()
);
assert_eq!(runtime.focused_widget(window_id).unwrap(), None);
assert!(
runtime
.render(window_id)
.unwrap()
.ime_composition_rect
.is_none()
);
assert!(
!runtime
.dispatch_event(
window_id,
Event::Keyboard(KeyboardEvent::new("BrowserBack", KeyState::Pressed)),
)
.unwrap()
);
}
#[test]
fn dispatch_event_reports_widget_handled_browser_back() {
let (mut runtime, window_id, _, leaf_counters) = build_runtime();
let initial = runtime.render(window_id).unwrap();
let focus_leaf = initial
.semantics
.iter()
.find(|node| node.name.as_deref() == Some("focus-leaf"))
.expect("focus leaf")
.id;
assert!(
runtime
.handle_semantics_action(window_id, focus_leaf, SemanticsActionRequest::Focus)
.unwrap()
);
assert!(
runtime
.dispatch_event(
window_id,
Event::Keyboard(KeyboardEvent::new("BrowserBack", KeyState::Pressed)),
)
.unwrap()
);
assert_eq!(leaf_counters.borrow().keyboard, 1);
}
#[test]
fn text_layout_retention_follows_retained_scene_handles() {
let system = TextSystem::new();
let first = system
.shape_text_persistent(
None,
"first",
Size::new(120.0, 24.0),
TextStyle::new(Color::WHITE),
&sui_text::FontRegistry::new(),
)
.unwrap();
let second = system
.shape_text_persistent(
None,
"second",
Size::new(120.0, 24.0),
TextStyle::new(Color::WHITE),
&sui_text::FontRegistry::new(),
)
.unwrap();
let mut scene = Scene::new();
scene.push(SceneCommand::DrawShapedText(sui_text::ShapedText::new(
Point::ZERO,
&first,
)));
super::retain_text_layouts_for_scene(&system, &scene);
let registry = system.text_layout_registry();
assert!(registry.contains(first.handle()));
assert!(!registry.contains(second.handle()));
}
#[test]
fn removing_a_window_tears_down_runtime_state() {
let (mut runtime, window_id, _, _) = build_runtime();
set_window_render_options(window_id, WindowRenderOptions::new(false, 1.0));
assert!(window_render_options(window_id).is_some());
runtime.remove_window(window_id).unwrap();
assert!(runtime.window_ids().is_empty());
assert!(window_render_options(window_id).is_none());
assert!(runtime.needs_render(window_id).is_err());
assert!(runtime.focus_state(window_id).is_err());
assert!(runtime.render(window_id).is_err());
}
}