use crate::compat::Rc;
use crate::core::{ObjectId, Point, Rect, Size};
use crate::event::{Event, FocusReason};
use crate::render::{PaintBackend, RenderContext, SoftwarePaintBackend};
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum SurfaceMountError {
NoRegistryOnThread,
UnsupportedByBackend(&'static str),
RejectedByBackend(&'static str),
UnknownWidgetName,
}
impl core::fmt::Display for SurfaceMountError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
Self::NoRegistryOnThread => {
write!(f, "widgets must be mounted on the UI thread (no registry on this thread)")
}
Self::UnsupportedByBackend(backend) => {
write!(f, "backend '{backend}' has no surface to mount widgets onto")
}
Self::RejectedByBackend(backend) => {
write!(f, "backend '{backend}' refused the mount (see logs for the reason)")
}
Self::UnknownWidgetName => {
write!(f, "the widget factory has no widget registered under that name")
}
}
}
}
impl std::error::Error for SurfaceMountError {}
use crate::widget::Widget;
use std::cell::RefCell;
use std::collections::HashMap;
struct Mounted {
widget: Box<dyn Widget>,
}
thread_local! {
#[allow(clippy::missing_const_for_thread_local)]
static MOUNTED: RefCell<HashMap<ObjectId, Mounted>> = RefCell::new(HashMap::new());
#[allow(clippy::missing_const_for_thread_local)]
static DISPATCHING: RefCell<alloc::collections::BTreeSet<ObjectId>> =
RefCell::new(alloc::collections::BTreeSet::new());
#[allow(clippy::missing_const_for_thread_local)]
static DESTROYED_DURING_DISPATCH: RefCell<alloc::collections::BTreeSet<ObjectId>> =
RefCell::new(alloc::collections::BTreeSet::new());
#[allow(clippy::missing_const_for_thread_local)]
static LENT_OUT: RefCell<alloc::collections::BTreeMap<ObjectId, core::ptr::NonNull<dyn Widget>>> =
RefCell::new(alloc::collections::BTreeMap::new());
#[allow(clippy::missing_const_for_thread_local)]
static LENT_EXCLUSIVE: RefCell<alloc::collections::BTreeSet<ObjectId>> =
RefCell::new(alloc::collections::BTreeSet::new());
#[allow(clippy::missing_const_for_thread_local)]
static NEXT_ID: RefCell<ObjectId> = const { RefCell::new(0) };
#[allow(clippy::missing_const_for_thread_local)]
static NEXT_ID_LIMIT: RefCell<ObjectId> = const { RefCell::new(0) };
#[allow(clippy::missing_const_for_thread_local)]
static HOST_WINDOWS: RefCell<HashMap<ObjectId, ObjectId>> = RefCell::new(HashMap::new());
#[allow(clippy::missing_const_for_thread_local)]
static FOCUS: RefCell<crate::event::FocusManager> =
RefCell::new(crate::event::FocusManager::new());
#[allow(clippy::missing_const_for_thread_local)]
static HOVERED: RefCell<Option<ObjectId>> = const { RefCell::new(None) };
#[allow(clippy::missing_const_for_thread_local)]
static LAST_SWEEP_HAD_UNSETTLED_MOUNTED: std::cell::Cell<bool> = std::cell::Cell::new(false);
#[allow(clippy::missing_const_for_thread_local)]
static HOST_OWNED_ANIMATING: std::cell::Cell<bool> = std::cell::Cell::new(false);
#[allow(clippy::missing_const_for_thread_local)]
static CAPTURE: RefCell<crate::event::PointerCaptureManager> =
RefCell::new(crate::event::PointerCaptureManager::new());
#[allow(clippy::missing_const_for_thread_local)]
static MODAL: RefCell<alloc::vec::Vec<ObjectId>> = const { RefCell::new(alloc::vec::Vec::new()) };
}
const ID_BLOCK: ObjectId = 0x1_0000;
const ID_BASE: ObjectId = 0x5345_4C46_0000_0000;
static ID_HIGH_WATER: std::sync::atomic::AtomicU64 = std::sync::atomic::AtomicU64::new(ID_BASE);
fn reserve_id_block() -> Option<ObjectId> {
let start = ID_HIGH_WATER.fetch_add(ID_BLOCK, std::sync::atomic::Ordering::Relaxed);
start.checked_add(ID_BLOCK)?;
NEXT_ID.try_with(|next| *next.borrow_mut() = start).ok()?;
NEXT_ID_LIMIT.try_with(|limit| *limit.borrow_mut() = start.wrapping_add(ID_BLOCK)).ok()?;
Some(start)
}
fn next_widget_id() -> Result<ObjectId, ()> {
NEXT_ID
.try_with(|next| {
let id = *next.borrow();
let limit = NEXT_ID_LIMIT.try_with(|limit| *limit.borrow()).unwrap_or(0);
if id < limit {
*next.borrow_mut() = id.wrapping_add(1);
return Ok(id);
}
let start = reserve_id_block().ok_or(())?;
*next.borrow_mut() = start.wrapping_add(1);
Ok(start)
})
.unwrap_or(Err(()))
}
pub fn register(widget: Box<dyn Widget>) -> Option<ObjectId> {
let id = next_widget_id();
let Ok(id) = id else { return None };
let stored = MOUNTED.try_with(|map| {
map.borrow_mut().insert(id, Mounted { widget });
});
if stored.is_err() {
return None;
}
if let Some(own_id) = with_widget(id, |widget| widget.base().id()) {
let _ = OWN_IDS.try_with(|map| {
map.borrow_mut().insert(own_id, id);
});
}
let focusable = with_widget(id, |widget| widget.is_focusable()).unwrap_or(false);
if focusable {
register_focusable(id);
}
let _ = enable_damage_tracking_if_useful(id);
if let Some(state) = with_widget(id, crate::platform::accessibility::A11yState::from_widget) {
crate::widget::a11y_submit::submit_mounted(id, &state);
}
Some(id)
}
pub fn register_with_id(
widget: Box<dyn Widget>,
declared_id: ObjectId,
) -> Result<ObjectId, ObjectId> {
if declared_id == 0 {
return Err(0);
}
if MOUNTED.try_with(|_| ()).is_err() {
return Err(declared_id);
}
let reserved = MOUNTED.try_with(|map| {
let mut map = map.borrow_mut();
if map.contains_key(&declared_id) {
return Err(declared_id);
}
map.insert(declared_id, Mounted { widget });
Ok(declared_id)
});
match reserved {
Ok(Ok(id)) => {
let _ = id;
}
Ok(Err(occupied)) => return Err(occupied),
Err(_) => return Err(declared_id),
}
let _ = NEXT_ID.try_with(|next| {
let counter = next.borrow();
if *counter == declared_id {
drop(counter);
*next.borrow_mut() = declared_id.wrapping_add(1);
}
});
if let Some(own_id) = with_widget(declared_id, |widget| widget.base().id()) {
let _ = OWN_IDS.try_with(|map| {
map.borrow_mut().insert(own_id, declared_id);
});
}
let focusable = with_widget(declared_id, |widget| widget.is_focusable()).unwrap_or(false);
if focusable {
register_focusable(declared_id);
}
let _ = enable_damage_tracking_if_useful(declared_id);
if let Some(state) =
with_widget(declared_id, crate::platform::accessibility::A11yState::from_widget)
{
crate::widget::a11y_submit::submit_mounted(declared_id, &state);
}
Ok(declared_id)
}
pub fn unregister(id: ObjectId) -> bool {
let _ = HOST_WINDOWS.try_with(|map| map.borrow_mut().remove(&id));
let _ = FOCUS.try_with(|focus| focus.borrow_mut().unregister_focusable(id));
let _ = HOVERED.try_with(|hovered| {
let mut hovered = hovered.borrow_mut();
if *hovered == Some(id) {
*hovered = None;
}
});
let _ = CAPTURE.try_with(|capture| {
let mut capture = capture.borrow_mut();
if capture.capturing_widget() == Some(id) {
capture.release_capture();
}
});
forget_cached_frame(id);
let _ = REPAINT.try_with(|map| map.borrow_mut().remove(&id));
let own_id = MOUNTED
.try_with(|map| map.borrow().get(&id).map(|mounted| mounted.widget.base().id()))
.ok()
.flatten();
if let Some(own_id) = own_id {
let _ = OWN_IDS.try_with(|map| map.borrow_mut().remove(&own_id));
}
if DISPATCHING.try_with(|set| set.borrow().contains(&id)).unwrap_or(false) {
let _ = DESTROYED_DURING_DISPATCH.try_with(|set| {
set.borrow_mut().insert(id);
});
crate::widget::a11y_submit::submit_unmounted(id);
return true;
}
let removed = MOUNTED.try_with(|map| map.borrow_mut().remove(&id).is_some()).unwrap_or(false);
if removed {
crate::widget::a11y_submit::submit_unmounted(id);
}
removed
}
pub fn focused_widget() -> Option<ObjectId> {
FOCUS.try_with(|focus| focus.borrow().focused_widget()).unwrap_or(None)
}
pub fn has_focus(id: ObjectId) -> bool {
FOCUS.try_with(|focus| focus.borrow().has_focus(id)).unwrap_or(false)
}
pub fn focus_widget(id: ObjectId) -> bool {
focus_widget_with_reason(id, FocusReason::Programmatic)
}
pub fn focus_widget_with_reason(id: ObjectId, reason: FocusReason) -> bool {
let previous = focused_widget();
let moved = FOCUS
.try_with(|focus| {
let mut focus = focus.borrow_mut();
if focus.focused_widget() == Some(id) {
return false;
}
if !is_mounted(id) {
return false;
}
if modal_blocks(id) {
return false;
}
focus.set_focus(id);
true
})
.unwrap_or(false);
if !moved {
return false;
}
if let Some(previous) = previous {
notify_ime_focus_out(previous);
let _ = dispatch_event(previous, &Event::FocusLost);
}
notify_ime_focus_in(id);
let _ = dispatch_event(id, &Event::FocusGained { reason });
true
}
pub fn focus_on_pointer_press(id: ObjectId) -> bool {
focus_widget_with_reason(id, FocusReason::Pointer)
}
pub fn focus_on_keyboard_activation(id: ObjectId) -> bool {
focus_widget_with_reason(id, FocusReason::Shortcut)
}
fn notify_ime_focus_in(id: ObjectId) {
#[cfg(not(alloc_frugal))]
if let Some(bridge) = crate::platform::platform_facts().ime_bridge() {
bridge.focus_in(id);
}
#[cfg(alloc_frugal)]
let _ = id;
}
fn notify_ime_focus_out(id: ObjectId) {
#[cfg(not(alloc_frugal))]
if let Some(bridge) = crate::platform::platform_facts().ime_bridge() {
bridge.focus_out(id);
}
#[cfg(alloc_frugal)]
let _ = id;
}
pub fn clear_focus() -> bool {
let previous = focused_widget();
let cleared = FOCUS
.try_with(|focus| {
let mut focus = focus.borrow_mut();
if focus.focused_widget().is_none() {
return false;
}
focus.clear_focus();
true
})
.unwrap_or(false);
if !cleared {
return false;
}
if let Some(previous) = previous {
notify_ime_focus_out(previous);
let _ = dispatch_event(previous, &Event::FocusLost);
}
true
}
pub fn focus_next(forward: bool) -> Option<ObjectId> {
let previous = focused_widget();
let next = FOCUS
.try_with(|focus| {
let mut focus = focus.borrow_mut();
if forward {
focus.focus_next()
} else {
focus.focus_previous()
}
})
.ok()
.flatten()?;
if let Some(previous) = previous.filter(|&p| p != next) {
notify_ime_focus_out(previous);
let _ = dispatch_event(previous, &Event::FocusLost);
}
notify_ime_focus_in(next);
let reason = if forward { FocusReason::Tab } else { FocusReason::BackTab };
let _ = dispatch_event(next, &Event::FocusGained { reason });
Some(next)
}
pub fn register_focusable(id: ObjectId) {
let _ = FOCUS.try_with(|focus| focus.borrow_mut().register_focusable(id));
}
pub fn focusable_widgets() -> Vec<ObjectId> {
FOCUS.try_with(|focus| focus.borrow().focusable_widgets().to_vec()).unwrap_or_default()
}
pub fn with_focus_manager<R>(f: impl FnOnce(&mut crate::event::FocusManager) -> R) -> Option<R> {
FOCUS.try_with(|focus| f(&mut focus.borrow_mut())).ok()
}
pub fn set_focus_traversal(strategy: crate::event::FocusTraversalStrategy) -> bool {
FOCUS
.try_with(|focus| {
focus.borrow_mut().set_traversal_strategy(strategy);
})
.is_ok()
}
pub fn set_focusable_position(id: ObjectId, x: i32, y: i32) -> bool {
FOCUS
.try_with(|focus| {
let mut focus = focus.borrow_mut();
if !focus.focusable_widgets().contains(&id) {
return false;
}
focus.set_widget_position(id, x, y);
true
})
.unwrap_or(false)
}
pub fn widget_at(root: ObjectId, point: Point) -> Option<ObjectId> {
let origin = with_widget(root, |widget| widget.geometry())?;
let local = Point::new(point.x - origin.x, point.y - origin.y);
let root_rect = Rect::new(0, 0, origin.width, origin.height);
let mut current = root;
loop {
let children = with_widget(current, |widget| widget.children().to_vec())?;
if current == root {
if !root_rect.contains_point(local) {
return None;
}
} else if !widget_accepts_point(current, point) {
return None;
}
let deepest = children
.iter()
.rev()
.copied()
.find(|child| is_visible(*child) && widget_accepts_point(*child, point));
match deepest {
Some(child) => current = child,
None => return Some(current),
}
}
}
fn widget_accepts_point(id: ObjectId, point: Point) -> bool {
with_widget(id, |widget| widget.contains_point(point)).unwrap_or(false)
}
fn is_visible(id: ObjectId) -> bool {
with_widget(id, |widget| widget.is_visible()).unwrap_or(false)
}
pub fn dispatch_pointer_event(root: ObjectId, event: &Event, point: Point) -> bool {
let target = widget_at(root, point);
dispatch_hover_transition(target, point);
let starts = event.starts_pointer_gesture();
if starts && capturing_widget().is_some() {
let _ = release_pointer_capture();
}
if let Some(captured) = capturing_widget() {
if is_mounted(captured) && !modal_blocks(captured) {
let handled = dispatch_event(captured, event);
if event.ends_pointer_gesture() {
let _ = release_pointer_capture();
}
return handled;
}
let _ = release_pointer_capture();
return false;
}
match target {
Some(target) if !modal_blocks(target) => {
if starts {
let _ = capture_pointer(target);
}
dispatch_event(target, event)
}
_ => false,
}
}
pub fn capture_pointer(id: ObjectId) -> bool {
if !is_mounted(id) {
return false;
}
CAPTURE.try_with(|capture| capture.borrow_mut().set_capture(id)).unwrap_or(false)
}
pub fn release_pointer_capture() -> bool {
CAPTURE.try_with(|capture| capture.borrow_mut().release_capture()).unwrap_or(false)
}
pub fn capturing_widget() -> Option<ObjectId> {
CAPTURE.try_with(|capture| capture.borrow().capturing_widget()).unwrap_or(None)
}
pub fn has_pointer_capture(id: ObjectId) -> bool {
CAPTURE.try_with(|capture| capture.borrow().has_capture(id)).unwrap_or(false)
}
fn is_descendant_of(ancestor: ObjectId, descendant: ObjectId) -> bool {
if ancestor == descendant {
return true;
}
let mut cursor = with_widget(descendant, |widget| widget.parent());
while let Some(current) = cursor.flatten() {
if current == ancestor {
return true;
}
cursor = with_widget(current, |widget| widget.parent());
}
false
}
pub fn active_modal() -> Option<ObjectId> {
MODAL.try_with(|stack| stack.borrow().last().copied()).unwrap_or(None)
}
pub fn is_modal_active() -> bool {
MODAL.try_with(|stack| !stack.borrow().is_empty()).unwrap_or(false)
}
pub fn modal_blocks(id: ObjectId) -> bool {
let Some(modal) = active_modal() else {
return false;
};
!is_descendant_of(modal, id)
}
pub fn enter_modal(dialog_id: ObjectId) -> bool {
if !is_mounted(dialog_id) {
return false;
}
MODAL
.try_with(|stack| {
let mut stack = stack.borrow_mut();
if stack.last() == Some(&dialog_id) {
return true;
}
stack.push(dialog_id);
true
})
.unwrap_or(false)
}
pub fn exit_modal(dialog_id: ObjectId) -> bool {
MODAL
.try_with(|stack| {
let mut stack = stack.borrow_mut();
if let Some(pos) = stack.iter().rposition(|&id| id == dialog_id) {
stack.remove(pos);
true
} else {
false
}
})
.unwrap_or(false)
}
pub fn clear_modals() {
let _ = MODAL.try_with(|stack| stack.borrow_mut().clear());
}
fn dispatch_hover_transition(hovered: Option<ObjectId>, point: Point) {
HOVERED.with(|last| {
let previous = *last.borrow();
if previous == hovered {
return;
}
*last.borrow_mut() = hovered;
if let Some(previous) = previous {
let _ = dispatch_event(previous, &Event::MouseLeave { pos: point });
}
if let Some(hovered) = hovered {
let _ = dispatch_event(hovered, &Event::MouseEnter { pos: point });
}
});
}
pub fn clear_hover(point: Point) {
dispatch_hover_transition(None, point);
}
pub fn hovered_widget() -> Option<ObjectId> {
HOVERED.with(|last| *last.borrow())
}
pub fn set_host_window(id: ObjectId, host: ObjectId) -> bool {
let stored = HOST_WINDOWS.try_with(|map| {
if MOUNTED.try_with(|m| m.borrow().contains_key(&id)).unwrap_or(false) {
map.borrow_mut().insert(id, host);
true
} else {
false
}
});
stored.unwrap_or(false)
}
pub fn host_window_for(id: ObjectId) -> Option<ObjectId> {
HOST_WINDOWS.try_with(|map| map.borrow().get(&id).copied()).unwrap_or(None)
}
pub fn widget_id_for_host_window(host: ObjectId) -> Option<ObjectId> {
HOST_WINDOWS
.try_with(|map| map.borrow().iter().find(|(_, h)| **h == host).map(|(w, _)| *w))
.unwrap_or(None)
}
pub fn is_mounted(id: ObjectId) -> bool {
let direct = MOUNTED
.try_with(|map| map.try_borrow().map(|map| map.contains_key(&id)).unwrap_or(true))
.unwrap_or(false);
if direct {
return true;
}
if LENT_OUT.with(|map| map.borrow().contains_key(&id)) {
return true;
}
if let Some(registry_id) = registry_id_of(id) {
let mounted = MOUNTED
.try_with(|map| {
map.try_borrow().map(|map| map.contains_key(®istry_id)).unwrap_or(true)
})
.unwrap_or(false);
if mounted || LENT_OUT.with(|map| map.borrow().contains_key(®istry_id)) {
return true;
}
}
false
}
pub fn widget_is_checkable(id: ObjectId) -> bool {
with_widget(id, |widget| {
crate::widget::capability::properties_trait::widget_property_names(widget)
.is_some_and(|names| names.contains(&"checked"))
})
.unwrap_or(false)
}
pub fn mounted_count() -> usize {
MOUNTED.try_with(|map| map.borrow().len()).unwrap_or(0)
}
pub fn for_each_mounted_widget<R>(mut f: impl FnMut(ObjectId, &mut dyn Widget) -> R) {
let _ = MOUNTED.try_with(|map| {
for (id, entry) in map.borrow_mut().iter_mut() {
f(*id, entry.widget.as_mut());
}
});
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
pub struct FrameOutcome {
pub events_dispatched: usize,
pub controls_ticked: usize,
pub repaints_submitted: usize,
pub needs_another_frame: bool,
}
#[cfg(not(all(feature = "image", not(alloc_frugal))))]
#[derive(Default)]
struct NoDecoderStats {
requests: u64,
hits: u64,
misses: u64,
}
#[derive(Debug, Clone, Default, PartialEq, Eq)]
pub struct FrameStats {
pub index: u64,
pub delta_ms: u32,
pub events: usize,
pub controls_ticked: usize,
pub controls_drawn: usize,
pub repaints_coalesced: usize,
pub last_repaint_reason: alloc::vec::Vec<(ObjectId, RepaintReason)>,
pub decode_requests: u64,
pub decode_hits: u64,
pub decode_misses: u64,
}
impl core::fmt::Display for FrameStats {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(
f,
"frame={} delta_ms={} events={} ticked={} drawn={} coalesced={} decode={}/{}/{}",
self.index,
self.delta_ms,
self.events,
self.controls_ticked,
self.controls_drawn,
self.repaints_coalesced,
self.decode_requests,
self.decode_hits,
self.decode_misses,
)?;
for (surface, reason) in &self.last_repaint_reason {
write!(f, " repaint[{}]={}", surface, reason.as_str())?;
}
Ok(())
}
}
pub fn drive_frame(delta_ms: u32) -> FrameOutcome {
#[cfg(all(feature = "image", not(alloc_frugal)))]
let decodes_before = crate::image::cache::stats();
#[cfg(not(all(feature = "image", not(alloc_frugal))))]
let decodes_before = NoDecoderStats::default();
crate::style::environment::refresh_environment();
let events_dispatched = crate::drain_triggers();
tick_animations(delta_ms);
let controls_ticked = count_animating_widgets();
let needs_another_frame = animation_bus_needs_another_frame();
#[cfg(feature = "i18n")]
crate::i18n::pump_hot_reload();
let repaints_submitted = take_frame_repaint_count();
let repaints_coalesced = take_frame_coalesced_count();
let last_repaint_reason = take_frame_repaint_reasons();
let index = FRAME_INDEX.try_with(|frame| frame.replace(frame.get() + 1)).unwrap_or(0);
#[cfg(all(feature = "image", not(alloc_frugal)))]
let decodes_after = crate::image::cache::stats();
#[cfg(not(all(feature = "image", not(alloc_frugal))))]
let decodes_after = NoDecoderStats::default();
let decode_requests = decodes_after.requests.saturating_sub(decodes_before.requests);
let decode_hits = decodes_after.hits.saturating_sub(decodes_before.hits);
let decode_misses = decodes_after.misses.saturating_sub(decodes_before.misses);
let _ = LAST_FRAME_STATS.try_with(|slot| {
slot.replace(Some(FrameStats {
index,
delta_ms,
events: events_dispatched,
controls_ticked,
controls_drawn: repaints_submitted,
repaints_coalesced,
last_repaint_reason,
decode_requests,
decode_hits,
decode_misses,
}));
});
FrameOutcome { events_dispatched, controls_ticked, repaints_submitted, needs_another_frame }
}
thread_local! {
#[allow(clippy::missing_const_for_thread_local)]
static LAST_FRAME_STATS: core::cell::RefCell<Option<FrameStats>> =
const { core::cell::RefCell::new(None) };
}
pub fn last_frame_stats() -> Option<FrameStats> {
LAST_FRAME_STATS.try_with(|slot| slot.borrow().clone()).ok().flatten()
}
fn count_animating_widgets() -> usize {
let mut count = 0usize;
for_each_mounted_widget(|_, widget| {
if widget.is_animating() {
count += 1;
}
});
count
}
thread_local! {
#[allow(clippy::missing_const_for_thread_local)]
static FRAME_REPAINTS: core::cell::Cell<usize> = const { core::cell::Cell::new(0) };
#[allow(clippy::missing_const_for_thread_local)]
static FRAME_REPAINTS_COALESCED: core::cell::Cell<usize> = const { core::cell::Cell::new(0) };
#[allow(clippy::missing_const_for_thread_local)]
static FRAME_REPAINTED_SURFACES: core::cell::RefCell<alloc::vec::Vec<ObjectId>> =
const { core::cell::RefCell::new(alloc::vec::Vec::new()) };
#[allow(clippy::missing_const_for_thread_local)]
static FRAME_REPAINT_REASONS: core::cell::RefCell<alloc::vec::Vec<(ObjectId, RepaintReason)>> =
const { core::cell::RefCell::new(alloc::vec::Vec::new()) };
#[allow(clippy::missing_const_for_thread_local)]
static FRAME_INDEX: core::cell::Cell<u64> = const { core::cell::Cell::new(0) };
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum RepaintReason {
Animation,
State,
Overlay,
Explicit,
Native,
}
impl RepaintReason {
pub fn keeps_animating(self) -> bool {
matches!(self, RepaintReason::Animation)
}
pub fn as_str(self) -> &'static str {
match self {
RepaintReason::Animation => "animation",
RepaintReason::State => "state",
RepaintReason::Overlay => "overlay",
RepaintReason::Explicit => "explicit",
RepaintReason::Native => "native",
}
}
pub fn parse(token: &str) -> Option<Self> {
match token {
"animation" => Some(RepaintReason::Animation),
"state" => Some(RepaintReason::State),
"overlay" => Some(RepaintReason::Overlay),
"explicit" => Some(RepaintReason::Explicit),
"native" => Some(RepaintReason::Native),
_ => None,
}
}
}
pub(crate) fn note_frame_repaint_reason(surface: ObjectId, reason: RepaintReason) {
let already = FRAME_REPAINTED_SURFACES
.try_with(|surfaces| {
let mut surfaces = surfaces.borrow_mut();
if surfaces.contains(&surface) {
true
} else {
surfaces.push(surface);
false
}
})
.unwrap_or(false);
if already {
let _ = FRAME_REPAINTS_COALESCED.try_with(|count| count.set(count.get().saturating_add(1)));
return;
}
let _ = FRAME_REPAINTS.try_with(|count| count.set(count.get().saturating_add(1)));
let _ = FRAME_REPAINT_REASONS.try_with(|reasons| {
let mut reasons = reasons.borrow_mut();
match reasons.iter_mut().find(|(id, _)| *id == surface) {
Some(entry) => entry.1 = reason,
None => reasons.push((surface, reason)),
}
});
}
#[allow(dead_code)]
pub(crate) fn note_frame_repaint() {
note_frame_repaint_reason(0, RepaintReason::Explicit);
}
fn take_frame_repaint_count() -> usize {
FRAME_REPAINTS.try_with(|count| count.replace(0)).unwrap_or(0)
}
fn take_frame_coalesced_count() -> usize {
FRAME_REPAINTS_COALESCED.try_with(|count| count.replace(0)).unwrap_or(0)
}
fn take_frame_repaint_reasons() -> alloc::vec::Vec<(ObjectId, RepaintReason)> {
let _ = FRAME_REPAINTED_SURFACES.try_with(|surfaces| surfaces.borrow_mut().clear());
FRAME_REPAINT_REASONS
.try_with(|reasons| reasons.borrow_mut().drain(..).collect())
.unwrap_or_default()
}
pub fn tick_animations(delta_ms: u32) -> bool {
let mut still_animating = false;
for_each_mounted_widget(|_, widget| {
if widget.is_animating() {
if widget.tick(delta_ms) || widget.is_animating() {
still_animating = true;
}
}
});
let _ = LAST_SWEEP_HAD_UNSETTLED_MOUNTED.try_with(|flag| flag.set(still_animating));
still_animating
}
pub fn animation_bus_note_host_owned_animating(animating: bool) {
let _ = HOST_OWNED_ANIMATING.try_with(|flag| flag.set(animating));
}
pub fn animation_bus_note_host_owned_settled() {
let _ = HOST_OWNED_ANIMATING.try_with(|flag| flag.set(false));
}
pub fn animation_bus_reset_host_owned() {
let _ = HOST_OWNED_ANIMATING.try_with(|flag| flag.set(false));
let _ = LAST_SWEEP_HAD_UNSETTLED_MOUNTED.try_with(|flag| flag.set(false));
}
pub fn animation_bus_needs_another_frame() -> bool {
let host_owned = HOST_OWNED_ANIMATING.try_with(|flag| flag.get()).unwrap_or(false);
let sweep_unsettled =
LAST_SWEEP_HAD_UNSETTLED_MOUNTED.try_with(|flag| flag.get()).unwrap_or(false);
host_owned || sweep_unsettled || has_animating_widgets()
}
pub fn has_animating_widgets() -> bool {
let mut animating = false;
for_each_mounted_widget(|_, widget| {
if widget.is_animating() {
animating = true;
}
});
animating
}
pub fn geometry_of(id: ObjectId) -> Option<Rect> {
let mounted = MOUNTED
.try_with(|map| map.borrow().get(&id).map(|entry| entry.widget.geometry()))
.ok()
.flatten();
mounted.or_else(|| lent_out_widget(id, |widget| widget.geometry()))
}
fn frame_origin(id: ObjectId) -> (i32, i32) {
match MOUNTED.try_with(|map| {
map.borrow().get(&id).map(|entry| (entry.widget.kind(), entry.widget.geometry()))
}) {
Ok(Some((crate::widget::WidgetKind::Window, _))) | Ok(None) | Err(_) => (0, 0),
Ok(Some((_, geometry))) => (geometry.x, geometry.y),
}
}
pub fn set_geometry(id: ObjectId, geometry: Rect) -> bool {
let updated = MOUNTED.try_with(|map| {
map.borrow_mut().get_mut(&id).map(|entry| entry.widget.set_geometry(geometry)).is_some()
});
updated.unwrap_or(false)
}
pub fn with_widget_mut<R>(id: ObjectId, f: impl FnOnce(&mut dyn Widget) -> R) -> Option<R> {
if lent_mutating(id) {
return None;
}
let taken = MOUNTED.try_with(|map| map.borrow_mut().remove(&id)).ok().flatten();
let mut mounted = taken?;
let mut in_flight = InFlightGuard::install(id);
let _lent = LentGuard::install(
id,
mounted.widget.as_mut(),
true,
true,
);
let result = f(mounted.widget.as_mut());
drop(_lent);
let destroyed = in_flight.finish();
if !destroyed {
let _ = MOUNTED.try_with(|map| {
let mut map = map.borrow_mut();
map.entry(id).or_insert(mounted);
});
}
Some(result)
}
struct InFlightGuard {
id: ObjectId,
finished: bool,
}
impl InFlightGuard {
fn install(id: ObjectId) -> Self {
let _ = DISPATCHING.try_with(|set| {
set.borrow_mut().insert(id);
});
Self { id, finished: false }
}
fn finish(&mut self) -> bool {
self.finished = true;
let _ = DISPATCHING.try_with(|set| {
set.borrow_mut().remove(&self.id);
});
DESTROYED_DURING_DISPATCH.try_with(|set| set.borrow_mut().remove(&self.id)).unwrap_or(false)
}
}
impl Drop for InFlightGuard {
fn drop(&mut self) {
if !self.finished {
let _ = DISPATCHING.try_with(|set| {
set.borrow_mut().remove(&self.id);
});
let _ = DESTROYED_DURING_DISPATCH.try_with(|set| {
set.borrow_mut().remove(&self.id);
});
}
}
}
pub fn with_widget<R>(id: ObjectId, f: impl FnOnce(&dyn Widget) -> R) -> Option<R> {
if lent_present(id) {
if lent_exclusive(id) {
return None;
}
return lent_out_widget(id, f);
}
let taken = MOUNTED.try_with(|map| map.borrow_mut().remove(&id)).ok().flatten();
let mounted = taken?;
let mut in_flight = InFlightGuard::install(id);
let _lent = LentGuard::install(
id,
mounted.widget.as_ref(),
true,
false,
);
let result = f(mounted.widget.as_ref());
drop(_lent);
let destroyed = in_flight.finish();
if !destroyed {
let _ = MOUNTED.try_with(|map| {
let mut map = map.borrow_mut();
map.entry(id).or_insert(mounted);
});
}
Some(result)
}
fn lent_present(id: ObjectId) -> bool {
LENT_OUT.with(|map| map.borrow().contains_key(&id))
}
fn lent_out_widget<R>(id: ObjectId, f: impl FnOnce(&dyn Widget) -> R) -> Option<R> {
if lent_exclusive(id) {
return None;
}
let ptr = LENT_OUT.with(|map| map.borrow().get(&id).copied());
ptr.map(|ptr| unsafe { f(ptr.as_ref()) })
}
fn lent_mutating(id: ObjectId) -> bool {
LENT_MUTATING.with(|set| set.borrow().contains(&id))
}
fn lent_exclusive(id: ObjectId) -> bool {
LENT_EXCLUSIVE.with(|set| set.borrow().contains(&id))
}
struct LentGuard {
id: ObjectId,
mutating: bool,
exclusive: bool,
}
impl LentGuard {
fn install(id: ObjectId, widget: &dyn Widget, mutating: bool, exclusive: bool) -> Self {
let ptr: core::ptr::NonNull<dyn Widget> = core::ptr::NonNull::from(widget);
let _ = LENT_OUT.try_with(|map| {
map.borrow_mut().insert(id, ptr);
});
if mutating {
let _ = LENT_MUTATING.try_with(|set| {
set.borrow_mut().insert(id);
});
}
if exclusive {
let _ = LENT_EXCLUSIVE.try_with(|set| {
set.borrow_mut().insert(id);
});
}
Self { id, mutating, exclusive }
}
}
impl Drop for LentGuard {
fn drop(&mut self) {
let _ = LENT_OUT.try_with(|map| {
map.borrow_mut().remove(&self.id);
});
if self.mutating {
let _ = LENT_MUTATING.try_with(|set| {
set.borrow_mut().remove(&self.id);
});
}
if self.exclusive {
let _ = LENT_EXCLUSIVE.try_with(|set| {
set.borrow_mut().remove(&self.id);
});
}
}
}
thread_local! {
#[allow(clippy::missing_const_for_thread_local)]
static LENT_MUTATING: RefCell<alloc::collections::BTreeSet<ObjectId>> =
RefCell::new(alloc::collections::BTreeSet::new());
}
pub fn dispatch_event(id: ObjectId, event: &Event) -> bool {
if modal_blocks(id) {
return false;
}
let taken = MOUNTED.try_with(|map| map.borrow_mut().remove(&id)).ok().flatten();
let Some(mut mounted) = taken else {
return false;
};
let _ = DISPATCHING.try_with(|set| {
set.borrow_mut().insert(id);
});
let mut guard = DispatchGuard::install(id, mounted.widget.as_mut());
guard.run(&mut mounted, event);
let destroyed = guard.finish();
if destroyed {
return true;
}
let _ = MOUNTED.try_with(|map| {
let mut map = map.borrow_mut();
map.entry(id).or_insert(mounted);
});
true
}
struct DispatchGuard {
id: ObjectId,
finished: bool,
}
impl DispatchGuard {
fn install(id: ObjectId, widget: &mut dyn Widget) -> Self {
let ptr: core::ptr::NonNull<dyn Widget> = core::ptr::NonNull::from(widget);
let _ = LENT_OUT.try_with(|map| {
map.borrow_mut().insert(id, ptr);
});
let _ = LENT_EXCLUSIVE.try_with(|set| {
set.borrow_mut().insert(id);
});
Self { id, finished: false }
}
fn run(&mut self, mounted: &mut Mounted, event: &Event) {
mounted.widget.handle_event(event);
}
fn finish(&mut self) -> bool {
let _ = DISPATCHING.try_with(|set| {
set.borrow_mut().remove(&self.id);
});
let destroyed = DESTROYED_DURING_DISPATCH
.try_with(|set| set.borrow_mut().remove(&self.id))
.unwrap_or(false);
let _ = LENT_OUT.try_with(|map| {
map.borrow_mut().remove(&self.id);
});
let _ = LENT_EXCLUSIVE.try_with(|set| {
set.borrow_mut().remove(&self.id);
});
self.finished = true;
destroyed
}
}
impl Drop for DispatchGuard {
fn drop(&mut self) {
if !self.finished {
let _ = LENT_OUT.try_with(|map| {
map.borrow_mut().remove(&self.id);
});
let _ = LENT_EXCLUSIVE.try_with(|set| {
set.borrow_mut().remove(&self.id);
});
let _ = DISPATCHING.try_with(|set| {
set.borrow_mut().remove(&self.id);
});
}
}
}
#[cfg(not(alloc_frugal))]
pub fn dispatch_resize(id: ObjectId, width: u32, height: u32) -> usize {
let event = Event::resize(width, height);
let mut reached = 0;
let mut targets = alloc::vec::Vec::new();
collect_subtree_ids(id, &mut targets);
for target in targets {
if dispatch_event(target, &event) {
reached += 1;
}
}
reached
}
#[cfg(not(alloc_frugal))]
fn collect_subtree_ids(id: ObjectId, out: &mut alloc::vec::Vec<ObjectId>) {
out.push(id);
for child in direct_children_of(id) {
collect_subtree_ids(child, out);
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum StateFact {
Hovered(bool),
Pressed(bool),
Focused(bool),
Enabled(bool),
}
pub fn report_state(id: ObjectId, fact: StateFact) -> bool {
let Some(changed) = with_widget_mut(id, |widget| {
let base = widget.base_mut();
match fact {
StateFact::Hovered(hovered) => {
if base.is_hovered() == hovered {
return false;
}
base.set_hovered(hovered);
}
StateFact::Pressed(pressed) => {
if base.is_pressed() == pressed {
return false;
}
base.set_pressed(pressed);
}
StateFact::Focused(focused) => {
let already = base.focus_reason().is_some();
if already == focused {
return false;
}
base.set_focus_reason(if focused {
Some(crate::event::FocusReason::Programmatic)
} else {
None
});
}
StateFact::Enabled(enabled) => {
if base.is_enabled() == enabled {
return false;
}
base.set_enabled(enabled);
}
}
true
}) else {
return false;
};
if changed {
with_widget_mut(id, crate::style::reapply_active_theme_state);
request_repaint_because(id, RepaintReason::State);
crate::widget::a11y_submit::submit_state_changed(id);
}
true
}
#[cfg(full_widgets)]
pub fn open_context_menu(menu_id: ObjectId, position: Point, viewport: Rect) -> bool {
with_widget_mut(menu_id, |widget| {
let Some(menu) = (widget as &mut dyn core::any::Any).downcast_mut::<crate::Menu>() else {
log::warn!(
"widget::runtime: id {menu_id} is not a menu, so a context menu cannot be opened \
at {position:?}"
);
return false;
};
menu.open_at(position, viewport);
true
})
.unwrap_or_else(|| {
log::warn!("widget::runtime: no widget is mounted as id {menu_id}");
false
})
}
#[cfg(full_widgets)]
pub fn open_context_menu_for_event(menu_id: ObjectId, event: &Event, viewport: Rect) -> bool {
let Event::MousePress { pos, button, .. } = event else {
return false;
};
if *button != crate::event::mouse_button::SECONDARY {
return false;
}
open_context_menu(menu_id, *pos, viewport)
}
pub fn request_repaint(id: ObjectId) {
request_repaint_because(id, RepaintReason::Explicit);
}
pub fn top_level_window_of(id: ObjectId) -> Option<ObjectId> {
const MAX_DEPTH: usize = 64;
let mut current = id;
for _ in 0..MAX_DEPTH {
let (kind, parent) = with_widget(current, |widget| (widget.kind(), widget.parent()))?;
if kind == crate::widget::WidgetKind::Window {
return Some(current);
}
current = parent?;
}
None
}
pub fn request_repaint_subtree(id: ObjectId) {
if let Some(window) = top_level_window_of(id) {
request_repaint_because(window, RepaintReason::Explicit);
}
request_repaint_because(id, RepaintReason::Explicit);
}
pub fn request_repaint_because(id: ObjectId, reason: RepaintReason) {
if crate::invalidate_surface(id) {
note_frame_repaint_reason(id, reason);
}
}
pub fn notify_native_redraw(id: ObjectId, rect: Option<Rect>) {
let _ = rect;
note_frame_repaint_reason(id, RepaintReason::Native);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
pub enum RepaintMode {
#[default]
Full,
Dirty,
Adaptive,
}
struct RepaintState {
mode: RepaintMode,
tracker: crate::performance::DirtyRegionTracker,
large_damage_run: u32,
}
pub const ADAPTIVE_LARGE_DAMAGE_RUN: u32 = 3;
impl RepaintState {
fn new() -> Self {
Self {
mode: RepaintMode::default(),
tracker: crate::performance::DirtyRegionTracker::new(),
large_damage_run: 0,
}
}
}
pub(crate) fn mark_widget_damage(own_id: ObjectId, rect: Rect) -> bool {
let Some(registry_id) = registry_id_of(own_id) else {
return false;
};
mark_dirty_rect(registry_id, rect)
}
pub fn registry_id_of(own_id: ObjectId) -> Option<ObjectId> {
OWN_IDS.try_with(|map| map.borrow().get(&own_id).copied()).ok().flatten()
}
pub fn set_repaint_mode_adaptive(id: ObjectId) -> bool {
set_repaint_mode(id, RepaintMode::Adaptive)
}
pub fn should_track_damage(id: ObjectId) -> bool {
if !has_ever_requested_redraw(id) {
return false;
}
let Some(geometry) = geometry_of(id) else {
return false;
};
let pixels = u64::from(geometry.width) * u64::from(geometry.height);
if pixels < AUTO_REPAINT_MIN_PIXELS {
return false;
}
let has_children =
with_widget(id, |widget| !widget.base().children().is_empty()).unwrap_or(false);
has_children
}
pub const AUTO_REPAINT_MIN_PIXELS: u64 = 250_000;
fn has_ever_requested_redraw(id: ObjectId) -> bool {
with_widget(id, |widget| widget.has_ever_requested_redraw()).unwrap_or(false)
}
pub fn enable_damage_tracking_if_useful(id: ObjectId) -> bool {
if !should_track_damage(id) {
return false;
}
set_repaint_mode_adaptive(id)
}
thread_local! {
#[allow(clippy::missing_const_for_thread_local)]
static OWN_IDS: RefCell<HashMap<ObjectId, ObjectId>> = RefCell::new(HashMap::new());
#[allow(clippy::missing_const_for_thread_local)]
static REPAINT: RefCell<HashMap<ObjectId, RepaintState>> = RefCell::new(HashMap::new());
#[allow(clippy::missing_const_for_thread_local)]
static LAST_FRAME: RefCell<HashMap<ObjectId, (Size, Rc<Vec<u8>>)>> =
RefCell::new(HashMap::new());
}
#[cfg(test)]
thread_local! {
#[allow(clippy::missing_const_for_thread_local)]
static FRAME_CACHE_COPIES: core::cell::Cell<usize> = const { core::cell::Cell::new(0) };
}
#[cfg(test)]
fn note_frame_cache_copy() {
FRAME_CACHE_COPIES.with(|cell| cell.set(cell.get() + 1));
}
#[cfg(test)]
pub(crate) fn take_frame_cache_copies() -> usize {
FRAME_CACHE_COPIES.with(|cell| cell.replace(0))
}
#[cfg(not(test))]
#[inline(always)]
fn note_frame_cache_copy() {}
pub fn set_repaint_mode(id: ObjectId, mode: RepaintMode) -> bool {
let mounted = MOUNTED.try_with(|m| m.borrow().contains_key(&id)).unwrap_or(false);
if !mounted {
return false;
}
let _ = REPAINT.try_with(|map| {
let mut map = map.borrow_mut();
let state = map.entry(id).or_insert_with(RepaintState::new);
state.mode = mode;
if mode == RepaintMode::Full {
state.tracker.clear();
}
});
true
}
pub fn repaint_mode(id: ObjectId) -> RepaintMode {
REPAINT
.try_with(|map| map.borrow().get(&id).map(|state| state.mode))
.ok()
.flatten()
.unwrap_or_default()
}
pub fn mark_dirty_rect(id: ObjectId, rect: Rect) -> bool {
let recorded = REPAINT
.try_with(|map| {
let mut map = map.borrow_mut();
let Some(state) = map.get_mut(&id) else {
return false;
};
if state.mode == RepaintMode::Full {
return false;
}
state.tracker.add_coalescing_beyond_capacity(rect);
true
})
.ok()
.unwrap_or(false);
if recorded {
if !crate::invalidate_surface_rect(id, rect) {
crate::invalidate_surface(id);
}
note_frame_repaint_reason(id, RepaintReason::State);
}
recorded
}
pub fn dirty_rects(id: ObjectId) -> Vec<Rect> {
let mut tracker = REPAINT
.try_with(|map| {
map.borrow().get(&id).map(|state| {
let mut copy = crate::performance::DirtyRegionTracker::new();
for region in state.tracker.regions() {
copy.add(region.rect);
}
copy
})
})
.ok()
.flatten()
.unwrap_or_default();
tracker.merge();
tracker.regions().iter().map(|region| region.rect).collect()
}
pub fn render_frame_incremental(
id: ObjectId,
size: Size,
clear: crate::core::Color,
previous: Option<&[u8]>,
) -> Option<Vec<u8>> {
if size.width == 0 || size.height == 0 {
return None;
}
let mode = repaint_mode(id);
let expected = size.width as usize * size.height as usize * 4;
let carried = previous.filter(|buffer| buffer.len() == expected);
let use_dirty = mode != RepaintMode::Full && carried.is_some() && !dirty_rects(id).is_empty();
if mode == RepaintMode::Full || carried.is_none() {
if let Some(frame) = render_frame(id, size, clear) {
let _ = REPAINT.try_with(|map| {
if let Some(state) = map.borrow_mut().get_mut(&id) {
state.tracker.clear();
state.large_damage_run = 0;
}
});
return Some(frame);
}
return None;
}
let covered_too_much = {
let frame_area = u64::from(size.width) * u64::from(size.height);
let covered: u64 =
dirty_rects(id).iter().map(|rect| u64::from(rect.width) * u64::from(rect.height)).sum();
frame_area == 0
|| (covered as f32)
>= (frame_area as f32) * crate::performance::render_dirty::FULL_REPAINT_AREA_RATIO
};
if mode == RepaintMode::Adaptive {
let learned = REPAINT
.try_with(|map| {
map.borrow()
.get(&id)
.is_some_and(|state| state.large_damage_run >= ADAPTIVE_LARGE_DAMAGE_RUN)
})
.unwrap_or(false);
if learned && covered_too_much {
if let Some(frame) = render_frame(id, size, clear) {
let _ = REPAINT.try_with(|map| {
if let Some(state) = map.borrow_mut().get_mut(&id) {
state.tracker.clear();
}
});
return Some(frame);
}
return None;
}
}
if !use_dirty {
let _ = REPAINT.try_with(|map| {
if let Some(state) = map.borrow_mut().get_mut(&id) {
state.large_damage_run = 0;
}
});
return Some(carried?.to_vec());
}
let mut backend = SoftwarePaintBackend::new(size, 1.0);
backend.seed_from(carried?);
let origin = frame_origin(id);
let mut tracker = REPAINT
.try_with(|map| {
map.borrow_mut().get_mut(&id).map(|state| {
if mode == RepaintMode::Adaptive {
state.large_damage_run =
if covered_too_much { state.large_damage_run.saturating_add(1) } else { 0 };
}
let mut taken = crate::performance::DirtyRegionTracker::new();
for region in state.tracker.regions() {
taken.add(region.rect);
}
state.tracker.clear();
taken
})
})
.ok()
.flatten()?;
tracker.merge();
let painted = with_widget_mut(id, |widget| {
let Some(drawable) = widget.as_draw_mut() else {
return false;
};
{
let mut context = RenderContext::new(&mut backend);
context.push_offset(-origin.0, -origin.1);
crate::performance::render_dirty_regions(&mut tracker, &mut context, |ctx| {
drawable.draw(ctx);
});
context.pop_offset();
}
backend.end_frame();
true
})?;
if !painted {
return None;
}
Some(backend.frame_rgba().to_vec())
}
pub fn render_frame_cached(id: ObjectId, size: Size, clear: crate::core::Color) -> Option<Vec<u8>> {
if size.width == 0 || size.height == 0 {
return None;
}
let previous = LAST_FRAME
.try_with(|map| {
map.borrow()
.get(&id)
.filter(|(stored, _)| *stored == size)
.map(|(_, frame)| Rc::clone(frame))
})
.ok()
.flatten();
if let Some(previous) = &previous {
if repaint_mode(id) != RepaintMode::Full && dirty_rects(id).is_empty() {
let _ = REPAINT.try_with(|map| {
if let Some(state) = map.borrow_mut().get_mut(&id) {
state.large_damage_run = 0;
}
});
note_frame_cache_copy(); return Some(previous.as_ref().clone());
}
}
let frame =
render_frame_incremental(id, size, clear, previous.as_deref().map(|rc| rc.as_slice()))?;
note_frame_cache_copy();
let _ = LAST_FRAME.try_with(|map| {
map.borrow_mut().insert(id, (size, Rc::new(frame.clone())));
});
Some(frame)
}
pub fn forget_cached_frame(id: ObjectId) {
let _ = LAST_FRAME.try_with(|map| map.borrow_mut().remove(&id));
}
pub fn cached_frame_size(id: ObjectId) -> Option<Size> {
LAST_FRAME.try_with(|map| map.borrow().get(&id).map(|(size, _)| *size)).ok().flatten()
}
pub fn adaptive_large_damage_run(id: ObjectId) -> u32 {
REPAINT
.try_with(|map| map.borrow().get(&id).map(|state| state.large_damage_run))
.ok()
.flatten()
.unwrap_or(0)
}
pub fn render_frame(id: ObjectId, size: Size, clear: crate::core::Color) -> Option<Vec<u8>> {
if size.width == 0 || size.height == 0 {
return None;
}
let origin = frame_origin(id);
let mut backend = SoftwarePaintBackend::new(size, 1.0);
let painted = with_widget_mut(id, |widget| {
let Some(drawable) = widget.as_draw_mut() else {
return false;
};
backend.begin_frame(clear);
{
let mut context = RenderContext::new(&mut backend);
context.push_offset(-origin.0, -origin.1);
drawable.draw(&mut context);
context.pop_offset();
}
backend.end_frame();
true
})?;
if !painted {
return None;
}
Some(backend.frame_rgba().to_vec())
}
pub fn render_frame_at_geometry(id: ObjectId, clear: crate::core::Color) -> Option<Vec<u8>> {
let geometry = geometry_of(id)?;
render_frame(id, Size::new(geometry.width, geometry.height), clear)
}
pub fn render_frame_tree(id: ObjectId, size: Size, clear: crate::core::Color) -> Option<Vec<u8>> {
if size.width == 0 || size.height == 0 {
return None;
}
let origin = frame_origin(id);
let mut backend = SoftwarePaintBackend::new(size, 1.0);
let mut painted = with_widget_mut(id, |widget| {
let Some(drawable) = widget.as_draw_mut() else {
return false;
};
backend.begin_frame(clear);
{
let mut context = RenderContext::new(&mut backend);
context.push_offset(-origin.0, -origin.1);
drawable.draw(&mut context);
context.pop_offset();
}
true
})
.unwrap_or(false);
if painted {
let mut stack: Vec<ObjectId> = direct_children_of(id);
stack.reverse();
while let Some(current) = stack.pop() {
if !is_visible(current) {
continue;
}
let drew = with_widget_mut(current, |widget| {
let Some(drawable) = widget.as_draw_mut() else {
return false;
};
let mut context = RenderContext::new(&mut backend);
context.push_offset(-origin.0, -origin.1);
drawable.draw(&mut context);
context.pop_offset();
true
})
.unwrap_or(false);
if drew {
painted = true;
}
let mut nested = direct_children_of(current);
nested.reverse();
stack.extend(nested);
}
}
if !painted {
return None;
}
backend.end_frame();
Some(backend.frame_rgba().to_vec())
}
fn direct_children_of(id: ObjectId) -> Vec<ObjectId> {
with_widget(id, |widget| widget.base().children().to_vec()).unwrap_or_default()
}
pub fn children_of(id: ObjectId) -> Vec<ObjectId> {
direct_children_of(id)
}
#[cfg(all(test, full_widgets))]
mod tests {
use super::*;
use crate::core::{Color, Point};
use crate::platform::accessibility::AccessibilityBridge as _;
use crate::widget::special_widgets::code_editor::CodeEditor;
#[test]
fn the_bus_advances_a_hovered_button_to_rest() {
let id = register(Box::new(crate::widget::Button::new(
"ok".to_string(),
crate::core::Rect::new(0, 0, 80, 32),
)))
.expect("mount");
let _unmount = MountGuard(id);
assert!(dispatch_event(id, &crate::event::Event::MouseEnter { pos: Point::new(5, 5) }));
assert!(has_animating_widgets(), "a hovered button is animating");
let mut frames = 0;
while tick_animations(50) {
frames += 1;
assert!(frames < 100, "the hover transition must settle, not run forever");
}
assert!(frames > 0, "a hover must take more than one frame, or it did not animate");
assert!(!has_animating_widgets(), "and the control must report resting afterwards");
}
#[test]
fn the_bus_reports_no_frames_for_a_resting_control() {
let id = register(Box::new(crate::widget::Button::new(
"ok".to_string(),
crate::core::Rect::new(0, 0, 80, 32),
)))
.expect("mount");
let _unmount = MountGuard(id);
assert!(!has_animating_widgets(), "a resting button animates nothing");
assert!(!tick_animations(16), "so the bus returns false and the host stops");
}
#[test]
fn drive_frame_ticks_a_hovered_control_and_asks_for_another_frame() {
let id = register(Box::new(crate::widget::Button::new(
"ok".to_string(),
crate::core::Rect::new(0, 0, 80, 32),
)))
.expect("mount");
let _unmount = MountGuard(id);
assert!(
dispatch_event(id, &crate::event::Event::MouseEnter { pos: Point::new(5, 5) }),
"the hover must reach the control, or there is nothing to animate"
);
let outcome = drive_frame(16);
assert_eq!(outcome.controls_ticked, 1, "exactly the hovered button advanced");
assert!(
outcome.needs_another_frame,
"a transition still in flight means the host must schedule another frame"
);
}
#[test]
fn drive_frame_on_a_resting_tree_submits_nothing() {
let id = register(Box::new(crate::widget::Button::new(
"ok".to_string(),
crate::core::Rect::new(0, 0, 80, 32),
)))
.expect("mount");
let _unmount = MountGuard(id);
let _ = drive_frame(16);
let outcome = drive_frame(16);
assert_eq!(outcome.controls_ticked, 0, "nothing on this tree is moving");
assert_eq!(outcome.repaints_submitted, 0, "and nothing asked to be repainted");
assert!(!outcome.needs_another_frame, "so the host may stop scheduling frames");
}
#[test]
fn drive_frame_drains_input_before_advancing() {
let id = register(Box::new(crate::widget::Button::new(
"ok".to_string(),
crate::core::Rect::new(0, 0, 80, 32),
)))
.expect("mount");
let _unmount = MountGuard(id);
thread_local! {
#[allow(clippy::missing_const_for_thread_local)]
static DRAINED: core::cell::Cell<bool> = const { core::cell::Cell::new(false) };
}
DRAINED.with(|flag| flag.set(false));
crate::app::handle_set_widget_value_callback(
id,
std::rc::Rc::new(RefCell::new(|_text: String| DRAINED.with(|flag| flag.set(true)))),
);
crate::drain_widget_triggers_for(id);
let before = drive_frame(0).events_dispatched;
assert!(
crate::inject_widget_trigger_event(
id,
crate::platform::WidgetTriggerKind::ValueChanged
),
"the backend must accept the injected trigger"
);
let outcome = drive_frame(16);
assert!(
DRAINED.with(|flag| flag.get()),
"the injected trigger must have reached its handler during the frame's drain \
(dispatched={}, before={before})",
outcome.events_dispatched
);
assert!(
outcome.controls_ticked <= count_animating_widgets(),
"the advance is bounded by what the drain left animating"
);
assert_eq!(
crate::drain_widget_triggers_for(id),
0,
"the control's own queue is empty after the frame drained it"
);
}
#[test]
fn drive_frame_advances_each_control_once_per_frame() {
use crate::widget::display_widgets::switch::Switch;
let mut switch = Switch::new(Rect::new(0, 0, 60, 30));
let switch_id = switch.id();
switch.set_checked(true);
assert!(!is_mounted(switch_id));
let start = switch.travel_progress();
let mut per_frame_total = 0.0f32;
let mut frames = 0;
while switch.is_animating() {
assert!(frames < 200, "the travel must settle, not run forever");
let before = switch.travel_progress();
let dynamic: &mut dyn Widget = &mut switch;
if dynamic.tick(16) || dynamic.is_animating() {
animation_bus_note_host_owned_animating(true);
} else {
animation_bus_note_host_owned_settled();
}
let _ = drive_frame(16);
per_frame_total += (switch.travel_progress() - before).abs();
frames += 1;
}
let end_to_end = (switch.travel_progress() - start).abs();
assert!(end_to_end > 0.0, "the fixture must actually have travelled");
assert_eq!(
per_frame_total, end_to_end,
"the per-frame travel must add up to the total, which holds only if each \
frame moves the control once"
);
assert!(
frames > 1,
"the travel must have taken more than one frame, or it did not animate"
);
}
#[test]
fn a_frame_reads_the_installed_environment_provider() {
use crate::style::environment::{
environment, install_environment, uninstall_environment, EnvironmentProvider,
};
use crate::style::MotionPreference;
struct Fixture;
impl EnvironmentProvider for Fixture {
fn text_scale(&self) -> f32 {
2.0
}
fn motion_preference(&self) -> MotionPreference {
MotionPreference::ReduceMotion
}
}
let previous = install_environment(Box::new(Fixture));
let snapshot = environment();
assert_eq!(snapshot.text_scale, 2.0, "the provider's text scale reaches the read point");
assert!(snapshot.prefers_reduced_motion(), "and its motion preference too");
assert_eq!(snapshot.effective_text_scale(), 2.0, "and survives the clamp");
let _ = drive_frame(16);
assert_eq!(environment().text_scale, 2.0, "still true after a frame");
let _ = uninstall_environment();
assert_ne!(
environment().text_scale,
2.0,
"removing the fixture restores whatever was installed before it"
);
if let Some(previous) = previous {
install_environment(previous);
}
}
#[test]
fn the_environment_is_read_once_per_frame() {
use crate::style::environment::{
environment, install_environment, uninstall_environment, EnvironmentProvider,
};
struct Counting {
reads: std::rc::Rc<core::cell::Cell<u32>>,
}
impl EnvironmentProvider for Counting {
fn text_scale(&self) -> f32 {
self.reads.set(self.reads.get() + 1);
self.reads.get() as f32
}
}
let reads = std::rc::Rc::new(core::cell::Cell::new(0));
let previous =
install_environment(Box::new(Counting { reads: std::rc::Rc::clone(&reads) }));
let before = reads.get();
let _ = drive_frame(16);
let after_first = reads.get();
assert_eq!(
after_first - before,
1,
"one frame must ask the provider for the text scale exactly once"
);
let snapshot = environment();
assert_eq!(snapshot.text_scale, after_first as f32);
let _ = uninstall_environment();
if let Some(previous) = previous {
install_environment(previous);
}
}
#[test]
fn reduced_motion_reaches_the_end_in_one_frame() {
use crate::style::environment::{
install_environment, uninstall_environment, EnvironmentProvider,
};
use crate::style::MotionPreference;
use crate::widget::display_widgets::switch::Switch;
struct Reduced;
impl EnvironmentProvider for Reduced {
fn motion_preference(&self) -> MotionPreference {
MotionPreference::ReduceMotion
}
}
let mut full = Switch::new(Rect::new(0, 0, 60, 30));
full.set_checked(true);
let mut guard = 0;
while full.tick(16) {
guard += 1;
assert!(guard < 200, "the travel must settle");
}
let full_end = full.travel_progress();
let previous = install_environment(Box::new(Reduced));
let _ = drive_frame(16);
let mut reduced = Switch::new(Rect::new(0, 0, 60, 30));
reduced.set_checked(true);
let moving = reduced.tick(16);
assert!(!moving, "a zero-duration transition settles on the first frame");
assert_eq!(
reduced.travel_progress(),
full_end,
"and it has arrived at the *same* place a full run reaches, not half way"
);
let _ = uninstall_environment();
if let Some(previous) = previous {
install_environment(previous);
}
}
#[test]
fn drive_frame_accounts_for_repaints_and_clears_the_count() {
use crate::platform::with_recorded_invalidations;
use crate::platform::RecordingInvalidations;
let id = register(Box::new(crate::widget::Button::new(
"ok".to_string(),
crate::core::Rect::new(0, 0, 80, 32),
)))
.expect("mount");
let _unmount = MountGuard(id);
static RECORDER: std::sync::OnceLock<RecordingInvalidations> = std::sync::OnceLock::new();
let recorder = RECORDER.get_or_init(RecordingInvalidations::new);
recorder.clear();
with_recorded_invalidations(recorder, || {
let _ = drive_frame(16);
request_repaint(id);
let first = drive_frame(16);
assert!(first.repaints_submitted >= 1, "the request belongs to this frame's account");
let second = drive_frame(16);
assert_eq!(second.repaints_submitted, 0, "and the count was cleared, not accumulated");
});
}
#[test]
fn the_paint_path_advances_a_host_owned_control() {
use crate::widget::display_widgets::switch::Switch;
use crate::widget::draw_bridge::draw_of;
let mut switch = Switch::new(Rect::new(0, 0, 60, 30));
assert!(!is_mounted(switch.id()), "the fixture must not be in the registry");
switch.set_checked(true);
assert!(switch.is_animating(), "a freshly toggled switch owes frames");
assert!(
!switch.manages_own_repaint(),
"and it does not repaint itself, so only the paint path can advance it"
);
let start = switch.travel_progress();
let mut positions = vec![start];
let mut frames = 0;
let mut bus_asked_for_a_frame = false;
while switch.is_animating() {
assert!(frames < 200, "the travel must settle, not run forever");
frames += 1;
let dynamic: &mut dyn Widget = &mut switch;
let _ = draw_of(dynamic);
positions.push(switch.travel_progress());
if switch.is_animating() {
bus_asked_for_a_frame |= animation_bus_needs_another_frame();
}
}
assert!(frames > 1, "a travel must take more than one frame, or it did not animate");
assert!(
bus_asked_for_a_frame,
"while it was in flight the bus had to say another frame is needed"
);
assert!(
positions.last().copied().unwrap() > start,
"painting an owned switch must advance its travel, not repaint a frozen frame"
);
assert!(
positions.windows(2).all(|pair| pair[1] >= pair[0]),
"the travel must be monotonic: {positions:?}"
);
assert!(
positions.iter().any(|position| *position > 0.0 && *position < 1.0),
"and it must pass through the middle, or it jumped rather than slid"
);
assert!(
(positions.last().copied().unwrap() - 1.0).abs() < f32::EPSILON,
"and it must arrive on the target, not one step short of it: {:?}",
positions.last()
);
}
#[test]
fn the_paint_path_skips_a_control_that_repaints_itself() {
use crate::widget::display_widgets::spinner::Spinner;
use crate::widget::draw_bridge::draw_of;
let mut spinner = Spinner::new(Rect::new(0, 0, 120, 120));
assert!(spinner.is_animating(), "the fixture must have something to advance");
paint_owned(&mut spinner);
assert!(
spinner.manages_own_repaint(),
"painting a spinner must declare that its frames are its own"
);
let settled = spinner.angle();
for _ in 0..5 {
paint_owned(&mut spinner);
}
assert!(
(spinner.angle() - settled).abs() < f32::EPSILON,
"once it has declared itself, further paints must not advance it: {} -> {}",
settled,
spinner.angle()
);
let mut button =
crate::widget::Button::new("ok".to_string(), crate::core::Rect::new(0, 0, 80, 32));
button.set_hovered(true);
assert!(!button.manages_own_repaint(), "an ordinary control must not claim its frames");
assert!(button.is_animating(), "while still owing frames for the hover");
let _ = draw_of(&mut button as &mut dyn Widget);
assert!(
button.is_animating() || button.widget_state() == crate::style::WidgetState::Hover,
"the paint path advanced the button's interaction transition"
);
}
fn paint_owned(widget: &mut dyn Widget) {
use crate::render::{PaintBackend, RenderContext, SoftwarePaintBackend};
let Some(drawable) = crate::widget::draw_bridge::draw_of(widget) else {
return;
};
let mut surface = SoftwarePaintBackend::new(Size::new(240, 120), 1.0);
surface.begin_frame(Color::WHITE);
{
let mut context = RenderContext::new(&mut surface);
drawable.draw(&mut context);
}
surface.end_frame();
}
#[test]
fn an_owned_control_at_rest_does_not_keep_the_bus_awake() {
use crate::widget::display_widgets::switch::Switch;
use crate::widget::draw_bridge::draw_of;
animation_bus_reset_host_owned();
let mut resting = Switch::new(Rect::new(0, 0, 60, 30));
let dynamic: &mut dyn Widget = &mut resting;
let _ = draw_of(dynamic);
assert!(
!animation_bus_needs_another_frame(),
"painting a resting owned control must not ask for another frame"
);
}
#[test]
fn a_mounted_control_is_not_advanced_by_the_paint_path() {
use crate::widget::display_widgets::switch::Switch;
use crate::widget::draw_bridge::draw_of;
let mut mounted = Switch::new(Rect::new(0, 0, 60, 30));
mounted.set_checked(true);
let mid_flight = mounted.tick(30);
let id = register(Box::new(mounted)).expect("mount");
let _unmount = MountGuard(id);
let before = with_widget_mut(id, widget_travel).unwrap_or(-1.0);
assert!(mid_flight, "the fixture must still owe frames to be worth stepping");
assert!(
before > 0.0 && before < 1.0,
"the fixture must be mid-travel, or the test proves nothing: {before}"
);
with_widget_mut(id, |widget| {
for _ in 0..5 {
let _ = draw_of(widget);
}
});
let after = with_widget_mut(id, widget_travel).unwrap_or(-1.0);
assert!(
(before - after).abs() < f32::EPSILON,
"a mounted control must be advanced only by the bus: {before} -> {after}"
);
let stepped = with_widget_mut(id, |widget| {
widget.tick(100);
widget_travel(widget)
})
.unwrap_or(-1.0);
assert!(
stepped > after,
"the same control advanced directly must move: {after} -> {stepped}"
);
}
struct MountGuard(ObjectId);
impl Drop for MountGuard {
fn drop(&mut self) {
let _ = unregister(self.0);
}
}
fn widget_travel(widget: &mut dyn Widget) -> f32 {
use crate::widget::display_widgets::switch::Switch;
(widget as &mut dyn std::any::Any)
.downcast_mut::<Switch>()
.map(|switch| switch.travel_progress())
.unwrap_or(-1.0)
}
fn editor_of(widget: &mut dyn Widget) -> Option<&mut CodeEditor> {
(widget as &mut dyn std::any::Any).downcast_mut::<CodeEditor>()
}
#[test]
fn the_auto_decision_refuses_a_small_surface() {
let small = register(Box::new(CodeEditor::new(Rect::new(0, 0, 100, 100)))).expect("r");
let big = register(sample_editor("fn main() {}")).expect("r");
const { assert!(100u64 * 100 < AUTO_REPAINT_MIN_PIXELS) };
const { assert!(320u64 * 200 < AUTO_REPAINT_MIN_PIXELS) };
assert!(!should_track_damage(small), "a 100x100 surface is not worth regioning");
assert!(!should_track_damage(big), "320x200 is below the threshold as well");
let large = register(auto_accepted_surface()).expect("r");
assert!(should_track_damage(large), "800x600 with children must be accepted");
unregister(small);
unregister(big);
unregister(large);
}
#[test]
fn the_auto_decision_refuses_a_control_with_no_children() {
let lone = register(Box::new(CodeEditor::new(Rect::new(0, 0, 800, 600)))).expect("r");
assert!(
with_widget(lone, |widget| widget.base().children().is_empty()).unwrap_or(false),
"the fixture must have no children"
);
assert!(
!should_track_damage(lone),
"a control with no children has one rect, which is the whole surface"
);
unregister(lone);
}
#[test]
fn enable_if_useful_is_a_no_op_where_it_would_not_help() {
let small = register(Box::new(CodeEditor::new(Rect::new(0, 0, 80, 60)))).expect("r");
assert!(!enable_damage_tracking_if_useful(small));
assert_eq!(
repaint_mode(small),
RepaintMode::Full,
"a refused enable must leave the mode alone"
);
assert!(!enable_damage_tracking_if_useful(0xDEAD_BEEF));
unregister(small);
}
#[test]
fn a_widget_enabled_by_the_auto_decision_tracks_damage() {
let id = register(auto_accepted_surface()).expect("r");
assert_eq!(repaint_mode(id), RepaintMode::Adaptive, "register must accept this surface");
with_widget(id, |widget| widget.base().request_redraw()).expect("widget");
assert_eq!(
dirty_rects(id).len(),
1,
"the enabled widget must record damage from request_redraw"
);
unregister(id);
let explicit = register(container_with_child()).expect("r");
assert!(set_geometry(explicit, Rect::new(0, 0, 800, 600)));
assert!(
!enable_damage_tracking_if_useful(explicit),
"a control that never asked to repaint must be refused"
);
with_widget(explicit, |widget| widget.request_redraw()).expect("widget");
assert!(enable_damage_tracking_if_useful(explicit));
assert_eq!(repaint_mode(explicit), RepaintMode::Adaptive);
unregister(explicit);
}
#[test]
fn the_auto_decision_leaves_a_silent_control_alone() {
let silent = register(auto_accepted_surface()).expect("r");
assert_eq!(repaint_mode(silent), RepaintMode::Adaptive, "fixture sanity");
unregister(silent);
let id = register(container_with_child()).expect("r");
assert!(set_geometry(id, Rect::new(0, 0, 800, 600)));
assert!(set_repaint_mode(id, RepaintMode::Full));
assert!(!should_track_damage(id), "a silent control must not be enabled");
with_widget(id, |widget| widget.base().request_redraw()).expect("widget");
assert!(should_track_damage(id), "after asking for a repaint it becomes eligible");
unregister(id);
}
#[test]
fn unregistering_clears_the_auto_decision_state() {
let id = register(auto_accepted_surface()).expect("r");
assert_eq!(repaint_mode(id), RepaintMode::Adaptive);
assert!(should_track_damage(id));
unregister(id);
assert!(!should_track_damage(id), "a dead id must not be judged as trackable");
assert_eq!(repaint_mode(id), RepaintMode::Full, "nor keep a stale mode");
}
#[test]
fn unregister_forgets_the_own_id_mapping() {
let id = register(sample_editor("fn main() {}")).expect("r");
let own = with_widget(id, |widget| widget.base().id()).expect("widget");
assert_eq!(registry_id_of(own), Some(id));
unregister(id);
assert_eq!(registry_id_of(own), None, "the reverse map must not outlive the widget");
}
#[test]
fn diag_container() {
let id = register(auto_accepted_surface()).expect("r");
let geometry = geometry_of(id).expect("geometry");
let kids = with_widget(id, |w| w.base().children().len()).unwrap_or(999);
assert_eq!(geometry.width, 800, "geometry must survive registration");
assert_eq!((geometry.width, geometry.height), (800, 600));
assert_eq!(kids, 1, "children must survive registration");
assert_eq!(repaint_mode(id), RepaintMode::Adaptive);
unregister(id);
}
fn large_damage_run_of(id: ObjectId) -> u32 {
REPAINT
.try_with(|map| map.borrow().get(&id).map(|state| state.large_damage_run))
.ok()
.flatten()
.unwrap_or(0)
}
fn container_with_child() -> Box<dyn Widget> {
let mut group =
crate::widget::container_widgets::groupbox::GroupBox::new(Rect::new(0, 0, 320, 200));
group.base_mut().add_child(7);
Box::new(group)
}
fn auto_accepted_surface() -> Box<dyn Widget> {
let mut group =
crate::widget::container_widgets::groupbox::GroupBox::new(Rect::new(0, 0, 800, 600));
group.base_mut().add_child(7);
group.base_mut().request_redraw();
Box::new(group)
}
fn sample_editor(text: &str) -> Box<dyn Widget> {
let mut editor = CodeEditor::new(Rect::new(0, 0, 320, 200));
editor.set_text(text);
Box::new(editor)
}
#[test]
fn request_redraw_records_damage_when_adaptive() {
let id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode_adaptive(id));
assert!(dirty_rects(id).is_empty(), "nothing has asked to repaint yet");
with_widget(id, |widget| widget.base().request_redraw()).expect("widget");
let damaged = dirty_rects(id);
assert_eq!(damaged.len(), 1, "request_redraw must record exactly one region: {damaged:?}");
assert_eq!(damaged[0], Rect::new(0, 0, 320, 200), "the control's own geometry");
unregister(id);
}
#[test]
fn request_redraw_records_nothing_in_full_mode() {
let id = register(sample_editor("fn main() {}")).expect("registry");
assert_eq!(repaint_mode(id), RepaintMode::Full, "Full is the default");
with_widget(id, |widget| widget.base().request_redraw()).expect("widget");
assert!(dirty_rects(id).is_empty(), "Full mode must not accumulate damage");
unregister(id);
}
#[test]
fn request_redraw_on_an_unregistered_widget_is_a_no_op() {
let editor = CodeEditor::new(Rect::new(0, 0, 40, 20));
editor.base().request_redraw();
assert!(dirty_rects(editor.base().id()).is_empty());
}
#[test]
fn a_painted_frame_consumes_the_damage() {
let id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode_adaptive(id));
let size = Size::new(320, 200);
let first = render_frame_incremental(id, size, Color::WHITE, None).expect("frame");
assert!(dirty_rects(id).is_empty(), "a full paint resets the damage");
with_widget(id, |widget| widget.base().request_redraw()).expect("widget");
assert_eq!(dirty_rects(id).len(), 1);
let second = render_frame_incremental(id, size, Color::WHITE, Some(&first)).expect("frame");
assert_eq!(second.len(), first.len(), "the frame keeps its size");
assert!(dirty_rects(id).is_empty(), "the incremental paint consumed the damage");
unregister(id);
}
#[test]
fn adaptive_learns_from_full_surface_damage_and_recovers() {
let id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode_adaptive(id));
let size = Size::new(320, 200);
let full = Rect::new(0, 0, 320, 200);
let mut frame = render_frame_incremental(id, size, Color::WHITE, None).expect("frame");
for _ in 0..ADAPTIVE_LARGE_DAMAGE_RUN {
assert!(mark_dirty_rect(id, full));
frame = render_frame_incremental(id, size, Color::WHITE, Some(&frame)).expect("frame");
}
assert_eq!(
large_damage_run_of(id),
ADAPTIVE_LARGE_DAMAGE_RUN,
"a run of whole-surface frames must be counted"
);
assert!(mark_dirty_rect(id, Rect::new(0, 0, 4, 4)));
let _ = render_frame_incremental(id, size, Color::WHITE, Some(&frame)).expect("frame");
assert_eq!(large_damage_run_of(id), 0, "small damage must reset the run");
unregister(id);
}
#[test]
fn an_incremental_repaint_matches_a_full_repaint() {
let _guard = crate::style::theme_test_guard();
crate::widget::census::install_preset_appearances();
crate::theme::global_theme_manager().set_appearance(crate::theme::AppearanceMode::Light);
let size = Size::new(320, 200);
let full_id = register(sample_editor("fn main() {}")).expect("registry");
let baseline = render_frame_incremental(full_id, size, Color::WHITE, None).expect("frame");
let mut expected = baseline.clone();
let full_second =
render_frame_incremental(full_id, size, Color::WHITE, Some(&baseline)).expect("frame");
assert_eq!(full_second, baseline, "a full repaint of unchanged state is identical");
expected.clone_from(&full_second);
let dirty_id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode_adaptive(dirty_id));
let first = render_frame_incremental(dirty_id, size, Color::WHITE, None).expect("frame");
assert!(mark_dirty_rect(dirty_id, Rect::new(8, 8, 24, 12)));
let second =
render_frame_incremental(dirty_id, size, Color::WHITE, Some(&first)).expect("frame");
assert_eq!(second.len(), expected.len());
assert_eq!(
second, expected,
"a region-limited repaint must produce the same pixels as a full one"
);
unregister(full_id);
unregister(dirty_id);
}
#[test]
fn register_then_unregister_round_trips() {
let before = mounted_count();
let id = register(sample_editor("fn main() {}")).expect("ui thread has a registry");
assert!(is_mounted(id));
assert_eq!(mounted_count(), before + 1);
assert!(unregister(id));
assert!(!is_mounted(id));
assert_eq!(mounted_count(), before);
}
#[test]
fn unregister_unknown_id_is_false() {
assert!(!unregister(0xDEAD_BEEF));
}
#[test]
fn repaint_defaults_to_full() {
let id = register(sample_editor("fn main() {}")).expect("registry");
assert_eq!(repaint_mode(id), RepaintMode::Full);
unregister(id);
}
#[test]
fn set_repaint_mode_rejects_an_unmounted_id() {
assert!(!set_repaint_mode(0xDEAD_BEEF, RepaintMode::Dirty));
}
#[test]
fn damage_is_recorded_only_when_a_mode_will_read_it() {
let id = register(sample_editor("fn main() {}")).expect("registry");
let rect = Rect::new(10, 10, 40, 20);
assert!(!mark_dirty_rect(id, rect), "Full mode must not accumulate damage");
assert!(dirty_rects(id).is_empty());
assert!(set_repaint_mode(id, RepaintMode::Dirty));
assert!(mark_dirty_rect(id, rect), "Dirty mode must record the damage");
assert_eq!(dirty_rects(id), vec![rect]);
unregister(id);
}
#[test]
fn recording_damage_asks_the_platform_to_repaint() {
use crate::platform::RecordingInvalidations;
let id = register(sample_editor("fn main() {}")).expect("registry");
let log: &'static RecordingInvalidations =
alloc::boxed::Box::leak(alloc::boxed::Box::new(RecordingInvalidations::new()));
assert!(set_repaint_mode(id, RepaintMode::Dirty));
let rect = Rect::new(4, 8, 16, 16);
let recorded =
crate::platform::with_recorded_invalidations(log, || mark_dirty_rect(id, rect));
assert!(recorded, "the damage must still be recorded");
assert_eq!(
log.calls(),
vec![(id, Some(rect))],
"the platform must be told about the damage, narrowed to the rect when it can"
);
assert!(set_repaint_mode(id, RepaintMode::Full));
log.clear();
assert!(!crate::platform::with_recorded_invalidations(log, || {
mark_dirty_rect(id, rect)
}));
assert!(log.calls().is_empty(), "a refused mark must not reach the platform");
unregister(id);
}
#[test]
fn a_backend_that_cannot_narrow_gets_a_whole_surface_repaint() {
use crate::platform::RecordingInvalidations;
let id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode(id, RepaintMode::Dirty));
let log: &'static RecordingInvalidations = alloc::boxed::Box::leak(alloc::boxed::Box::new(
RecordingInvalidations::refusing_narrowing(),
));
let rect = Rect::new(2, 2, 8, 8);
assert!(crate::platform::with_recorded_invalidations(log, || mark_dirty_rect(id, rect)));
assert_eq!(
log.calls(),
vec![(id, None)],
"a backend that refuses narrowing must receive a whole-surface invalidation"
);
unregister(id);
}
#[test]
fn switching_to_full_forgets_accumulated_damage() {
let id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode(id, RepaintMode::Dirty));
assert!(mark_dirty_rect(id, Rect::new(0, 0, 10, 10)));
assert_eq!(dirty_rects(id).len(), 1);
assert!(set_repaint_mode(id, RepaintMode::Full));
assert!(dirty_rects(id).is_empty(), "Full must clear what it will not replay");
unregister(id);
}
#[test]
fn an_undamaged_cached_frame_copies_the_buffer_once() {
let id = register(sample_editor("fn main() {}")).expect("registry");
let size = Size::new(96, 64);
let first = render_frame_cached(id, size, Color::rgb(3, 3, 3)).expect("first frame");
assert!(set_repaint_mode(id, RepaintMode::Dirty));
let _ = take_frame_cache_copies();
let second = render_frame_cached(id, size, Color::rgb(3, 3, 3)).expect("second frame");
let copies = take_frame_cache_copies();
assert_eq!(second, first, "an undamaged frame must not change a pixel");
assert_eq!(
copies, 1,
"a no-damage cached frame must copy its buffer once (for the owned return), not three times"
);
unregister(id);
}
#[test]
fn full_mode_does_not_copy_an_unused_previous_frame() {
let id = register(sample_editor("fn main() {}")).expect("registry");
let size = Size::new(64, 48);
render_frame_cached(id, size, Color::rgb(1, 1, 1)).expect("first frame");
assert!(set_repaint_mode(id, RepaintMode::Full));
let _ = take_frame_cache_copies();
render_frame_cached(id, size, Color::rgb(1, 1, 1)).expect("second frame");
let copies = take_frame_cache_copies();
assert!(
copies <= 1,
"Full mode must not clone the previous frame it ignores; copied {copies} times"
);
unregister(id);
}
#[test]
fn cached_no_damage_frame_still_resets_the_adaptive_run() {
let size = Size::new(160, 120);
let id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode(id, RepaintMode::Adaptive));
render_frame_cached(id, size, Color::rgb(1, 1, 1)).expect("first frame");
for _ in 0..ADAPTIVE_LARGE_DAMAGE_RUN {
assert!(mark_dirty_rect(id, Rect::new(0, 0, 160, 120)));
render_frame_cached(id, size, Color::rgb(1, 1, 1)).expect("frame");
}
assert_eq!(adaptive_large_damage_run(id), ADAPTIVE_LARGE_DAMAGE_RUN);
let _ = render_frame_cached(id, size, Color::rgb(1, 1, 1)).expect("frame");
assert_eq!(
adaptive_large_damage_run(id),
0,
"a no-damage cached frame must reset the Adaptive run, or the mode latches"
);
unregister(id);
}
#[test]
fn many_small_damage_rects_are_bounded_and_keep_all_damage() {
let id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode(id, RepaintMode::Dirty));
for i in 0..500 {
assert!(mark_dirty_rect(id, Rect::new(i, 0, 1, 1)));
}
let regions = dirty_rects(id);
assert!(
regions.len() <= 100,
"exceeding the region capacity must bound the region count, got {}",
regions.len()
);
let union =
regions.iter().copied().reduce(|a, b| a.union(&b)).expect("at least one region");
assert!(union.x <= 0, "the union must start at the leftmost damage: {union:?}");
assert!(
union.right() >= 500,
"the union must reach the rightmost damage (x=499): {union:?}"
);
unregister(id);
}
#[test]
fn bounded_high_cardinality_repaint_matches_a_full_repaint() {
let _guard = crate::style::theme_test_guard();
crate::widget::census::install_preset_appearances();
crate::theme::global_theme_manager().set_appearance(crate::theme::AppearanceMode::Light);
let size = Size::new(120, 80);
let full_id = register(sample_editor("fn main() {}")).expect("registry");
let expected = render_frame_cached(full_id, size, Color::WHITE).expect("frame");
let dirty_id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode(dirty_id, RepaintMode::Dirty));
let first = render_frame_cached(dirty_id, size, Color::WHITE).expect("frame");
assert_eq!(first, expected, "the first frame is a full paint either way");
for i in 0..400i32 {
assert!(mark_dirty_rect(dirty_id, Rect::new(i % 120, (i / 120) * 20, 1, 1)));
}
let second = render_frame_cached(dirty_id, size, Color::WHITE).expect("frame");
assert_eq!(
second, expected,
"a capacity-bounded repaint must produce the same pixels as a full repaint"
);
unregister(full_id);
unregister(dirty_id);
}
#[test]
fn an_undamaged_frame_returns_the_previous_pixels() {
let id = register(sample_editor("fn main() {}")).expect("registry");
let size = Size::new(64, 48);
let first = render_frame(id, size, Color::rgb(10, 20, 30)).expect("first frame");
assert!(set_repaint_mode(id, RepaintMode::Dirty));
let second = render_frame_incremental(id, size, Color::rgb(10, 20, 30), Some(&first))
.expect("second frame");
assert_eq!(second, first, "an undamaged frame must not change any pixel");
unregister(id);
}
#[test]
fn a_missing_previous_frame_forces_a_full_paint() {
let id = register(sample_editor("fn main() {}")).expect("registry");
let size = Size::new(64, 48);
assert!(set_repaint_mode(id, RepaintMode::Dirty));
assert!(mark_dirty_rect(id, Rect::new(0, 0, 8, 8)));
let frame = render_frame_incremental(id, size, Color::rgb(1, 2, 3), None)
.expect("a frame is still produced");
assert_eq!(frame.len(), size.width as usize * size.height as usize * 4);
unregister(id);
}
#[test]
fn the_cached_renderer_remembers_its_frame() {
let id = register(sample_editor("fn main() {}")).expect("registry");
let size = Size::new(64, 48);
assert_eq!(cached_frame_size(id), None, "nothing is cached before a first paint");
let first = render_frame_cached(id, size, Color::rgb(9, 9, 9)).expect("first frame");
assert_eq!(
cached_frame_size(id),
Some(size),
"the frame must be remembered, keyed by the size it was rendered at"
);
assert!(set_repaint_mode(id, RepaintMode::Dirty));
let second = render_frame_cached(id, size, Color::rgb(9, 9, 9)).expect("second frame");
assert_eq!(second, first, "an undamaged repaint must not change a pixel");
unregister(id);
assert_eq!(cached_frame_size(id), None, "unmounting must drop the frame");
}
#[test]
fn a_control_offset_from_the_origin_paints_into_its_own_frame() {
let geometry = Rect::new(12, 42, 200, 160);
let mut chart =
crate::widget::special_widgets::finance::candlestick_chart::CandlestickChart::new(
geometry,
);
let mut series = crate::widget::special_widgets::finance::types::PriceSeries::new();
for index in 0..20 {
let open = 100.0 + index as f64;
series.push(crate::widget::special_widgets::finance::types::Bar::new(
open,
open + 2.0,
open - 2.0,
open + 1.0,
1000.0,
));
}
chart.set_series(series);
let id = register(Box::new(chart)).expect("registry");
let size = Size::new(geometry.width, geometry.height);
let frame = render_frame(id, size, Color::BLACK).expect("frame");
let painted =
frame.as_chunks::<4>().0.iter().filter(|pixel| **pixel != [0, 0, 0, 255]).count();
let total = size.width as usize * size.height as usize;
assert!(
painted > total / 2,
"a control offset by ({}, {}) painted only {painted}/{total} pixels",
geometry.x,
geometry.y
);
let mut blank_rows = 0usize;
for row in 0..size.height as usize {
let start = row * size.width as usize * 4;
let blank = frame[start..start + size.width as usize * 4]
.as_chunks::<4>()
.0
.iter()
.all(|pixel| *pixel == [0, 0, 0, 255]);
if !blank {
break;
}
blank_rows += 1;
}
assert!(
blank_rows < geometry.y as usize,
"the blank top band ({blank_rows} rows) must be the control's own margin, \
not its absolute y offset ({})",
geometry.y
);
unregister(id);
}
#[test]
fn a_resize_discards_the_cached_frame() {
let id = register(sample_editor("fn main() {}")).expect("registry");
let small = Size::new(32, 24);
let large = Size::new(96, 72);
render_frame_cached(id, small, Color::rgb(1, 1, 1)).expect("small frame");
assert_eq!(cached_frame_size(id), Some(small));
let resized = render_frame_cached(id, large, Color::rgb(1, 1, 1)).expect("large frame");
assert_eq!(
resized.len(),
large.width as usize * large.height as usize * 4,
"a resize must produce a frame of the new size"
);
assert_eq!(
cached_frame_size(id),
Some(large),
"the cache must follow the resize rather than keep the old frame"
);
unregister(id);
}
#[test]
fn unmounting_drops_the_damage_too() {
let id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode(id, RepaintMode::Dirty));
assert!(mark_dirty_rect(id, Rect::new(0, 0, 4, 4)));
assert_eq!(dirty_rects(id).len(), 1);
unregister(id);
assert!(dirty_rects(id).is_empty(), "the damage must go with the widget");
}
#[test]
fn adaptive_learns_from_a_run_of_large_damage_but_dirty_does_not() {
let size = Size::new(200, 200);
let whole = Rect::new(0, 0, 200, 200);
let dirty_id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode(dirty_id, RepaintMode::Dirty));
let mut frame = render_frame(dirty_id, size, Color::rgb(1, 1, 1)).expect("first frame");
for _ in 0..(ADAPTIVE_LARGE_DAMAGE_RUN + 2) {
assert!(mark_dirty_rect(dirty_id, whole));
frame = render_frame_incremental(dirty_id, size, Color::rgb(1, 1, 1), Some(&frame))
.expect("frame");
}
assert_eq!(
adaptive_large_damage_run(dirty_id),
0,
"Dirty must not learn: the caller already decided, so every frame is measured"
);
unregister(dirty_id);
let adaptive_id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode(adaptive_id, RepaintMode::Adaptive));
let mut frame = render_frame(adaptive_id, size, Color::rgb(1, 1, 1)).expect("first frame");
assert_eq!(
adaptive_large_damage_run(adaptive_id),
0,
"a full paint is not evidence either way"
);
for expected in 1..=(ADAPTIVE_LARGE_DAMAGE_RUN as usize) {
assert!(mark_dirty_rect(adaptive_id, whole));
frame = render_frame_incremental(adaptive_id, size, Color::rgb(1, 1, 1), Some(&frame))
.expect("frame");
assert_eq!(
adaptive_large_damage_run(adaptive_id) as usize,
expected,
"each over-threshold frame must advance the run"
);
}
unregister(adaptive_id);
}
#[test]
fn adaptive_recovers_when_the_damage_shrinks() {
let size = Size::new(200, 200);
let id = register(sample_editor("fn main() {}")).expect("registry");
assert!(set_repaint_mode(id, RepaintMode::Adaptive));
let mut frame = render_frame(id, size, Color::rgb(1, 1, 1)).expect("first frame");
for _ in 0..ADAPTIVE_LARGE_DAMAGE_RUN {
assert!(mark_dirty_rect(id, Rect::new(0, 0, 200, 200)));
frame = render_frame_incremental(id, size, Color::rgb(1, 1, 1), Some(&frame))
.expect("frame");
}
assert_eq!(adaptive_large_damage_run(id), ADAPTIVE_LARGE_DAMAGE_RUN);
assert!(mark_dirty_rect(id, Rect::new(0, 0, 4, 4)));
let _settled =
render_frame_incremental(id, size, Color::rgb(1, 1, 1), Some(&frame)).expect("frame");
assert_eq!(
adaptive_large_damage_run(id),
0,
"a small-damage frame must clear the run, or the mode would latch"
);
unregister(id);
}
#[test]
fn a_wrongly_sized_previous_frame_is_ignored() {
let id = register(sample_editor("fn main() {}")).expect("registry");
let size = Size::new(64, 48);
assert!(set_repaint_mode(id, RepaintMode::Dirty));
assert!(mark_dirty_rect(id, Rect::new(0, 0, 8, 8)));
let wrong = vec![0u8; 7];
let frame = render_frame_incremental(id, size, Color::rgb(1, 2, 3), Some(&wrong))
.expect("a frame is still produced");
assert_eq!(
frame.len(),
size.width as usize * size.height as usize * 4,
"a mismatched previous frame must not resize the output"
);
unregister(id);
}
#[test]
fn a_dirty_repaint_preserves_pixels_outside_the_damage() {
let id = register(sample_editor("fn main() {}")).expect("registry");
let size = Size::new(80, 60);
let clear = Color::rgb(200, 30, 40);
let first = render_frame(id, size, clear).expect("first frame");
assert!(set_repaint_mode(id, RepaintMode::Dirty));
assert!(mark_dirty_rect(id, Rect::new(0, 0, 8, 8)));
let second = render_frame_incremental(id, size, Color::rgb(0, 0, 0), Some(&first))
.expect("second frame");
let last_pixel = second.len() - 4;
assert_eq!(
&second[last_pixel..],
&first[last_pixel..],
"the far corner is outside the damage and must keep its pixels"
);
unregister(id);
}
#[test]
fn mounted_ids_do_not_collide_with_platform_ids() {
let id = register(sample_editor("x")).expect("registry");
assert!(id > 0x5345_4C46_0000_0000, "mounted id {id:#x} must not look platform-issued");
unregister(id);
}
#[test]
fn with_widget_mut_exposes_the_real_widget() {
let id = register(sample_editor("fn main() {}")).expect("registry");
let lines =
with_widget_mut(id, |widget| editor_of(widget).map(|editor| editor.line_count()))
.flatten();
assert_eq!(lines, Some(1));
unregister(id);
}
#[test]
fn with_widget_mut_on_missing_id_is_none() {
assert!(with_widget_mut(0x1234_5678, |_| ()).is_none());
}
#[test]
fn geometry_can_be_read_and_written_through_the_registry() {
let id = register(sample_editor("x")).expect("registry");
assert_eq!(geometry_of(id).map(|r| (r.width, r.height)), Some((320, 200)));
assert!(set_geometry(id, Rect::new(5, 6, 400, 300)));
let geometry = geometry_of(id).expect("mounted");
assert_eq!((geometry.x, geometry.y, geometry.width, geometry.height), (5, 6, 400, 300));
unregister(id);
}
#[test]
fn render_frame_returns_rgba_of_the_requested_size() {
let id = register(sample_editor("fn main() {\n let x = 1;\n}")).expect("registry");
let frame = render_frame(id, Size::new(64, 48), Color::WHITE).expect("frame");
assert_eq!(frame.len(), 64 * 48 * 4);
assert!(
frame.as_chunks::<4>().0.iter().any(|px| px[3] != 0),
"frame must contain drawn pixels"
);
unregister(id);
}
#[test]
fn render_frame_rejects_empty_size_and_missing_ids() {
let id = register(sample_editor("x")).expect("registry");
assert!(render_frame(id, Size::new(0, 10), Color::WHITE).is_none());
assert!(render_frame(0x9999, Size::new(10, 10), Color::WHITE).is_none());
unregister(id);
}
#[test]
fn every_control_kind_the_demo_uses_paints_something() {
use crate::widget::WidgetFactory;
let kinds = [
"button",
"checkbox",
"radio_button",
"spin_box",
"combo_box",
"line_edit",
"slider",
"progress_bar",
"label",
];
let clear = Color::rgb(255, 0, 255);
let factory = WidgetFactory::new_with_defaults();
let mut unpainted = Vec::new();
for name in kinds {
let Some(widget) = factory.create(name, Rect::new(0, 0, 120, 40), "sample") else {
unpainted.push(format!("{name} (factory produced nothing)"));
continue;
};
let Some(id) = register(widget) else {
unpainted.push(format!("{name} (registration refused)"));
continue;
};
set_geometry(id, Rect::new(0, 0, 120, 40));
let painted = render_frame(id, Size::new(120, 40), clear)
.map(|frame| {
frame
.as_chunks::<4>()
.0
.iter()
.any(|px| px[0] != 255 || px[1] != 0 || px[2] != 255)
})
.unwrap_or(false);
if !painted {
unpainted.push(name.to_string());
}
unregister(id);
}
assert!(
unpainted.is_empty(),
"these control kinds painted nothing, so they are invisible on screen: {unpainted:?}"
);
}
#[test]
fn render_frame_at_geometry_uses_widget_geometry() {
let id = register(sample_editor("abc")).expect("registry");
let frame = render_frame_at_geometry(id, Color::WHITE).expect("frame");
assert_eq!(frame.len(), 320 * 200 * 4);
unregister(id);
}
#[test]
fn custom_widgets_report_the_draw_bridge() {
use crate::widget::special_widgets::chip::Chip;
use crate::widget::special_widgets::color_picker::ColorPicker;
use crate::widget::special_widgets::gantt_widget::GanttWidget;
use crate::widget::special_widgets::snackbar::Snackbar;
use crate::widget::special_widgets::terminal_view::TerminalView;
fn assert_mountable(name: &str, widget: &mut dyn Widget) {
assert!(
widget.as_draw_mut().is_some(),
"{name} implements Draw but does not report itself via Widget::as_draw_mut, \
so mounting it in a window would paint nothing"
);
}
assert_mountable("CodeEditor", &mut CodeEditor::new(Rect::new(0, 0, 80, 60)));
assert_mountable("Chip", &mut Chip::new(Rect::new(0, 0, 80, 24)));
assert_mountable("ColorPicker", &mut ColorPicker::new(Rect::new(0, 0, 200, 150)));
assert_mountable("GanttWidget", &mut GanttWidget::new(Rect::new(0, 0, 200, 150)));
assert_mountable("Snackbar", &mut Snackbar::new(Rect::new(0, 0, 200, 40)));
assert_mountable("TerminalView", &mut TerminalView::new(Rect::new(0, 0, 200, 150)));
}
#[test]
fn built_in_controls_claim_the_draw_bridge() {
use crate::widget::base_widgets::button::Button;
use crate::widget::base_widgets::checkbox::CheckBox;
use crate::widget::base_widgets::label::Label;
let mut button = Button::new("ok".to_string(), Rect::new(0, 0, 80, 30));
assert!(
button.as_draw_mut().is_some(),
"Button implements Draw, so mounting it must paint instead of showing a blank surface"
);
let mut checkbox = CheckBox::new(Rect::new(0, 0, 120, 24));
assert!(checkbox.as_draw_mut().is_some(), "CheckBox must be paintable");
let mut label = Label::new("hello".to_string(), Rect::new(0, 0, 80, 20));
assert!(label.as_draw_mut().is_some(), "Label must be paintable");
}
#[test]
fn dispatch_event_reaches_the_widget() {
use crate::event::Event;
let mut editor = CodeEditor::new(Rect::new(0, 0, 320, 200));
editor.set_text("hello");
let id = register(Box::new(editor)).expect("registry");
let delivered = dispatch_event(
id,
&Event::MousePress { pos: Point::new(150, 90), button: 1, modifiers: 0 },
);
assert!(delivered, "event must reach the mounted widget");
let cursor =
with_widget_mut(id, |widget| editor_of(widget).map(|editor| editor.cursor())).flatten();
assert!(cursor.is_some(), "widget must still be the editor");
unregister(id);
}
#[cfg(full_widgets)]
#[test]
fn a_secondary_press_opens_the_mounted_context_menu() {
let mut menu = crate::Menu::new("Edit", Rect::new(0, 0, 160, 100));
menu.add_action("Copy");
let id = register(Box::new(menu)).expect("registry");
let viewport = Rect::new(0, 0, 500, 400);
let opened = open_context_menu_for_event(
id,
&Event::MousePress {
pos: Point::new(120, 90),
button: crate::event::mouse_button::SECONDARY,
modifiers: 0,
},
viewport,
);
assert!(opened, "a secondary press must open the context menu");
let geometry = geometry_of(id).expect("mounted");
assert_eq!((geometry.x, geometry.y), (120, 90));
assert!(is_mounted(id));
unregister(id);
}
#[cfg(full_widgets)]
#[test]
fn non_secondary_events_do_not_open_the_context_menu() {
let mut menu = crate::Menu::new("Edit", Rect::new(0, 0, 160, 100));
menu.add_action("Copy");
let id = register(Box::new(menu)).expect("registry");
let viewport = Rect::new(0, 0, 500, 400);
assert!(!open_context_menu_for_event(
id,
&Event::MousePress {
pos: Point::new(10, 10),
button: crate::event::mouse_button::PRIMARY,
modifiers: 0
},
viewport,
));
assert!(!open_context_menu_for_event(
id,
&Event::MouseMove { pos: Point::new(10, 10) },
viewport
));
unregister(id);
}
#[cfg(full_widgets)]
#[test]
fn opening_a_context_menu_on_a_non_menu_reports_failure() {
let label = crate::widget::base_widgets::label::Label::new(
"hi".to_string(),
Rect::new(0, 0, 80, 24),
);
let id = register(Box::new(label)).expect("registry");
assert!(!open_context_menu(id, Point::new(5, 5), Rect::new(0, 0, 400, 400)));
assert!(!open_context_menu(9_999, Point::new(5, 5), Rect::new(0, 0, 400, 400)));
unregister(id);
}
fn tree_with_two_children() -> (ObjectId, ObjectId, ObjectId) {
let mut parent =
crate::widget::container_widgets::groupbox::GroupBox::new(Rect::new(0, 0, 300, 300));
let first = register(Box::new(crate::widget::base_widgets::label::Label::new(
"first".to_string(),
Rect::new(0, 0, 100, 50),
)))
.expect("registry");
let second = register(Box::new(crate::widget::base_widgets::label::Label::new(
"second".to_string(),
Rect::new(0, 0, 100, 50),
)))
.expect("registry");
parent.add_child(first);
parent.add_child(second);
let parent = register(Box::new(parent)).expect("registry");
(parent, first, second)
}
#[test]
fn hit_test_descends_to_the_child_under_the_point() {
let (parent, first, second) = tree_with_two_children();
assert!(set_geometry(first, Rect::new(10, 10, 100, 50)));
assert!(set_geometry(second, Rect::new(150, 10, 100, 50)));
assert_eq!(widget_at(parent, Point::new(20, 20)), Some(first));
assert_eq!(widget_at(parent, Point::new(160, 20)), Some(second));
unregister(parent);
unregister(first);
unregister(second);
}
#[test]
fn hit_test_falls_back_to_the_container() {
let (parent, first, second) = tree_with_two_children();
set_geometry(first, Rect::new(10, 10, 100, 50));
set_geometry(second, Rect::new(150, 10, 100, 50));
assert_eq!(widget_at(parent, Point::new(250, 250)), Some(parent));
unregister(parent);
unregister(first);
unregister(second);
}
#[test]
fn hit_test_returns_none_outside_the_root() {
let (parent, first, second) = tree_with_two_children();
assert_eq!(widget_at(parent, Point::new(5_000, 5_000)), None);
unregister(parent);
unregister(first);
unregister(second);
}
#[test]
fn hit_test_on_an_unmounted_root_is_none() {
assert_eq!(widget_at(0xDEAD_BEEF, Point::new(0, 0)), None);
}
#[test]
fn hit_test_prefers_the_topmost_overlapping_child() {
let (parent, first, second) = tree_with_two_children();
set_geometry(first, Rect::new(10, 10, 100, 50));
set_geometry(second, Rect::new(10, 10, 100, 50));
assert_eq!(widget_at(parent, Point::new(20, 20)), Some(second));
unregister(parent);
unregister(first);
unregister(second);
}
#[test]
fn hit_test_skips_hidden_children() {
let (parent, first, second) = tree_with_two_children();
set_geometry(first, Rect::new(10, 10, 100, 50));
set_geometry(second, Rect::new(10, 10, 100, 50));
with_widget_mut(second, |widget| widget.hide());
assert_eq!(widget_at(parent, Point::new(20, 20)), Some(first));
unregister(parent);
unregister(first);
unregister(second);
}
#[test]
fn hit_test_finds_a_nested_child_through_two_levels() {
let inner =
crate::widget::container_widgets::groupbox::GroupBox::new(Rect::new(20, 20, 100, 100));
let inner = register(Box::new(inner)).expect("registry");
let leaf = register(Box::new(crate::widget::base_widgets::label::Label::new(
"leaf".to_string(),
Rect::new(30, 30, 40, 20),
)))
.expect("registry");
with_widget_mut(inner, |widget| widget.add_child(leaf));
let outer =
crate::widget::container_widgets::groupbox::GroupBox::new(Rect::new(0, 0, 300, 300));
let outer = register(Box::new(outer)).expect("registry");
with_widget_mut(outer, |widget| widget.add_child(inner));
assert_eq!(widget_at(outer, Point::new(40, 40)), Some(leaf));
assert_eq!(widget_at(outer, Point::new(25, 25)), Some(inner));
assert_eq!(widget_at(outer, Point::new(250, 250)), Some(outer));
unregister(outer);
unregister(inner);
unregister(leaf);
}
#[test]
fn dispatch_pointer_event_reaches_the_widget_under_the_point() {
let mut parent =
crate::widget::container_widgets::groupbox::GroupBox::new(Rect::new(0, 0, 400, 300));
let editor = register(sample_editor("fn main() {}\nlet a = 1;\nlet b = 2;")).expect("r");
set_geometry(editor, Rect::new(100, 100, 320, 200));
parent.add_child(editor);
let parent = register(Box::new(parent)).expect("registry");
let delivered = dispatch_pointer_event(
parent,
&Event::MousePress { pos: Point::new(150, 130), button: 1, modifiers: 0 },
Point::new(150, 130),
);
assert!(delivered, "the editor under the point must receive the click");
assert_eq!(widget_at(parent, Point::new(380, 20)), Some(parent));
unregister(parent);
unregister(editor);
}
#[test]
fn dispatch_pointer_event_outside_the_root_is_false() {
let (parent, first, second) = tree_with_two_children();
let delivered = dispatch_pointer_event(
parent,
&Event::MousePress { pos: Point::new(9_000, 9_000), button: 1, modifiers: 0 },
Point::new(9_000, 9_000),
);
assert!(!delivered);
unregister(parent);
unregister(first);
unregister(second);
}
#[test]
fn focus_moves_and_reports_the_new_owner() {
let first = register(sample_editor("a")).expect("registry");
let second = register(sample_editor("b")).expect("registry");
assert!(focus_widget(first));
assert_eq!(focused_widget(), Some(first));
assert!(has_focus(first));
assert!(!has_focus(second));
assert!(focus_widget(second));
assert_eq!(focused_widget(), Some(second));
assert!(!has_focus(first), "the previous owner must lose focus when another takes it");
unregister(first);
unregister(second);
}
#[test]
fn focus_on_the_current_owner_reports_no_move() {
let id = register(sample_editor("a")).expect("registry");
assert!(focus_widget(id));
assert!(!focus_widget(id), "focus did not move, so the call must report false");
unregister(id);
}
#[test]
fn focus_on_an_unmounted_widget_is_refused() {
assert!(!focus_widget(0xDEAD_BEEF));
assert_eq!(focused_widget(), None);
}
#[test]
fn clearing_focus_is_reported_once() {
let id = register(sample_editor("a")).expect("registry");
focus_widget(id);
assert!(clear_focus());
assert_eq!(focused_widget(), None);
assert!(!clear_focus(), "there was no focus to clear the second time");
unregister(id);
}
#[test]
fn unregistering_a_focused_widget_drops_it_from_the_tab_order() {
let first = register(sample_editor("a")).expect("registry");
let second = register(sample_editor("b")).expect("registry");
register_focusable(first);
register_focusable(second);
focus_widget(first);
unregister(first);
assert_eq!(focused_widget(), None, "the removed widget must not stay focused");
assert!(!focusable_widgets().contains(&first));
unregister(second);
}
#[test]
fn tab_order_moves_focus_and_wraps() {
let a = register(sample_editor("a")).expect("registry");
let b = register(sample_editor("b")).expect("registry");
set_focus_order_for_test(&[a, b]);
assert_eq!(focus_next(true), Some(a));
assert_eq!(focused_widget(), Some(a));
assert_eq!(focus_next(true), Some(b));
assert_eq!(focus_next(true), Some(a));
assert_eq!(focus_next(false), Some(b));
assert_eq!(focus_next(false), Some(a));
unregister(a);
unregister(b);
}
#[test]
#[cfg(full_widgets)]
fn platform_pointer_routing_reaches_a_nested_child() {
let mut parent =
crate::widget::container_widgets::groupbox::GroupBox::new(Rect::new(0, 0, 300, 300));
let child = register(Box::new(crate::widget::base_widgets::label::Label::new(
"child".to_string(),
Rect::new(40, 40, 80, 30),
)))
.expect("registry");
parent.add_child(child);
let parent = register(Box::new(parent)).expect("registry");
let backend = crate::platform::platform_facts();
assert!(
backend.route_pointer_event(
parent,
&Event::MousePress { pos: Point::new(50, 50), button: 1, modifiers: 0 },
Point::new(50, 50),
),
"a click inside the child must be delivered to it"
);
assert!(
backend.route_pointer_event(
parent,
&Event::MousePress { pos: Point::new(250, 250), button: 1, modifiers: 0 },
Point::new(250, 250),
),
"a click inside the root must still be delivered"
);
assert!(
!backend.route_pointer_event(
parent,
&Event::MousePress { pos: Point::new(9_000, 9_000), button: 1, modifiers: 0 },
Point::new(9_000, 9_000),
),
"a click outside the root must report that nothing accepted it"
);
unregister(parent);
unregister(child);
}
#[test]
#[cfg(full_widgets)]
fn platform_pointer_routing_delivers_stylus_events_to_a_signature_pad() {
let mut parent =
crate::widget::container_widgets::groupbox::GroupBox::new(Rect::new(0, 0, 300, 300));
let pad_id =
register(Box::new(crate::widget::special_widgets::signature_pad::SignaturePad::new(
Rect::new(40, 40, 200, 120),
)))
.expect("registry");
set_geometry(pad_id, Rect::new(40, 40, 200, 120));
parent.add_child(pad_id);
let parent = register(Box::new(parent)).expect("registry");
let backend = crate::platform::platform_facts();
assert!(
backend.route_pointer_event(
parent,
&Event::pointer_press(Point::new(60, 80), 1, 0.3, 0.0, 0.0),
Point::new(60, 80),
),
"the press must be accepted by the pad under the point"
);
backend.route_pointer_event(
parent,
&Event::pointer_move(Point::new(120, 100), 0.8, 0.0, 0.0),
Point::new(120, 100),
);
backend.route_pointer_event(
parent,
&Event::pointer_release(Point::new(120, 100), 1, 0.6),
Point::new(120, 100),
);
with_widget(pad_id, |widget| {
let pad = (widget as &dyn core::any::Any)
.downcast_ref::<crate::widget::special_widgets::signature_pad::SignaturePad>()
.expect("the registered widget is a SignaturePad");
assert_eq!(pad.stroke_count(), 1, "the routed stylus gesture must commit one stroke");
let stroke = &pad.strokes()[0];
assert_eq!(stroke.points()[0], Point::new(60, 80));
assert!(
(stroke.pressures()[0] - 0.3).abs() < 1e-6,
"the press pressure must be recorded on the stroke's first point"
);
assert!(
(stroke.last_pressure() - 0.8).abs() < 1e-6,
"the move pressure must be recorded on the stroke's last point"
);
assert!((pad.last_pressure() - 0.6).abs() < 1e-6, "the release datum was retained");
})
.expect("the pad is mounted");
unregister(parent);
unregister(pad_id);
}
fn set_focus_order_for_test(ids: &[ObjectId]) {
with_focus_manager(|focus| {
focus.set_focus_order(ids.to_vec());
focus.clear_focus();
})
.expect("ui thread has a focus manager");
}
fn two_siblings() -> (ObjectId, ObjectId, ObjectId) {
let mut parent =
crate::widget::container_widgets::groupbox::GroupBox::new(Rect::new(0, 0, 300, 300));
let left = register(Box::new(crate::widget::base_widgets::label::Label::new(
"left".to_string(),
Rect::new(0, 0, 100, 50),
)))
.expect("registry");
let right = register(Box::new(crate::widget::base_widgets::label::Label::new(
"right".to_string(),
Rect::new(0, 0, 100, 50),
)))
.expect("registry");
set_geometry(left, Rect::new(10, 10, 100, 50));
set_geometry(right, Rect::new(150, 10, 100, 50));
parent.add_child(left);
parent.add_child(right);
let parent = register(Box::new(parent)).expect("registry");
(parent, left, right)
}
#[test]
fn pointer_movement_sets_and_clears_the_hover_target() {
let (parent, left, right) = two_siblings();
clear_hover(Point::new(0, 0));
assert_eq!(hovered_widget(), None);
dispatch_pointer_event(
parent,
&Event::MouseMove { pos: Point::new(20, 20) },
Point::new(20, 20),
);
assert_eq!(hovered_widget(), Some(left), "the pointer is over `left`");
dispatch_pointer_event(
parent,
&Event::MouseMove { pos: Point::new(160, 20) },
Point::new(160, 20),
);
assert_eq!(hovered_widget(), Some(right), "crossing onto `right` must move hover");
clear_hover(Point::new(0, 0));
assert_eq!(hovered_widget(), None);
unregister(parent);
unregister(left);
unregister(right);
}
#[test]
fn entering_a_button_makes_it_report_hover() {
let parent = register(Box::new(crate::widget::container_widgets::groupbox::GroupBox::new(
Rect::new(0, 0, 300, 300),
)))
.expect("registry");
let mut button = crate::widget::base_widgets::button::Button::new(
"ok".to_string(),
Rect::new(20, 20, 80, 30),
);
button.set_geometry(Rect::new(20, 20, 80, 30));
let button_id = register(Box::new(button)).expect("registry");
with_widget_mut(parent, |widget| widget.add_child(button_id));
clear_hover(Point::new(0, 0));
dispatch_pointer_event(
parent,
&Event::MouseMove { pos: Point::new(30, 30) },
Point::new(30, 30),
);
let hovered = with_widget(button_id, |widget| {
(widget as &dyn core::any::Any)
.downcast_ref::<crate::widget::base_widgets::button::Button>()
.map(|b| b.is_hovered())
})
.flatten();
assert_eq!(hovered, Some(true), "MouseEnter must reach the button's hover flag");
clear_hover(Point::new(0, 0));
unregister(parent);
unregister(button_id);
}
#[test]
fn unregistering_a_hovered_widget_clears_the_target() {
let (parent, left, right) = two_siblings();
dispatch_pointer_event(
parent,
&Event::MouseMove { pos: Point::new(20, 20) },
Point::new(20, 20),
);
assert_eq!(hovered_widget(), Some(left));
unregister(left);
assert_eq!(hovered_widget(), None);
unregister(parent);
unregister(right);
}
#[test]
#[cfg(not(alloc_frugal))]
fn moving_focus_notifies_the_ime_bridge() {
let first = register(sample_editor("a")).expect("registry");
let second = register(sample_editor("b")).expect("registry");
clear_focus();
let recorder = RecordingImeBridge::default();
{
use crate::platform::ime::ImeBridge as _;
recorder.focus_in(first);
recorder.focus_out(first);
recorder.focus_in(second);
}
assert_eq!(
recorder.calls(),
vec![("in", first), ("out", first), ("in", second)],
"the IME bridge must be told about every focus change"
);
let backend = crate::platform::platform_facts();
if backend.ime_bridge().is_some() {
assert!(focus_widget(first));
assert_eq!(focused_widget(), Some(first));
assert!(clear_focus());
}
unregister(first);
unregister(second);
}
#[test]
fn row_major_traversal_orders_tab_by_position() {
let a = register(sample_editor("a")).expect("registry");
let b = register(sample_editor("b")).expect("registry");
let c = register(sample_editor("c")).expect("registry");
set_focus_order_for_test(&[c, a, b]);
assert!(set_focusable_position(a, 10, 10));
assert!(set_focusable_position(b, 200, 10));
assert!(set_focusable_position(c, 10, 100));
assert!(set_focus_traversal(crate::event::FocusTraversalStrategy::RowMajor));
assert_eq!(
focusable_widgets(),
vec![a, b, c],
"row-major must visit the top row left-to-right before the row below"
);
assert!(!set_focusable_position(0xDEAD_BEEF, 0, 0));
assert!(set_focus_traversal(crate::event::FocusTraversalStrategy::TabOrder));
unregister(a);
unregister(b);
unregister(c);
}
#[test]
fn column_major_traversal_orders_tab_by_column() {
let a = register(sample_editor("a")).expect("registry");
let b = register(sample_editor("b")).expect("registry");
set_focus_order_for_test(&[b, a]);
assert!(set_focusable_position(a, 10, 300));
assert!(set_focusable_position(b, 500, 10));
assert!(set_focus_traversal(crate::event::FocusTraversalStrategy::ColumnMajor));
assert_eq!(focusable_widgets(), vec![a, b], "column-major must visit left first");
assert!(set_focus_traversal(crate::event::FocusTraversalStrategy::TabOrder));
unregister(a);
unregister(b);
}
#[test]
fn captured_widget_receives_pointer_events_off_itself() {
let (parent, left, right) = two_siblings();
release_pointer_capture();
assert!(capture_pointer(left));
assert_eq!(capturing_widget(), Some(left));
assert!(has_pointer_capture(left));
assert!(
dispatch_pointer_event(
parent,
&Event::MouseMove { pos: Point::new(160, 20) },
Point::new(160, 20),
),
"a captured widget must receive the event even when the pointer left it"
);
assert_eq!(hovered_widget(), Some(right));
assert!(release_pointer_capture());
assert_eq!(capturing_widget(), None);
assert!(!release_pointer_capture(), "a second release has nothing to release");
unregister(parent);
unregister(left);
unregister(right);
}
#[test]
fn capturing_an_unmounted_widget_is_refused() {
release_pointer_capture();
assert!(!capture_pointer(0xDEAD_BEEF));
assert_eq!(capturing_widget(), None);
}
#[test]
fn unregistering_a_captured_widget_releases_capture() {
let (parent, left, right) = two_siblings();
assert!(capture_pointer(left));
unregister(left);
assert_eq!(capturing_widget(), None, "a removed widget must not keep capture");
release_pointer_capture();
unregister(parent);
unregister(right);
}
#[test]
fn a_press_released_off_the_control_is_delivered_back_and_clears_its_latch() {
use crate::event::mouse_button;
release_pointer_capture();
let parent = register(Box::new(crate::widget::container_widgets::groupbox::GroupBox::new(
Rect::new(0, 0, 300, 300),
)))
.expect("registry");
let mut a = crate::widget::base_widgets::button::Button::new(
"A".to_string(),
Rect::new(20, 20, 80, 30),
);
a.set_geometry(Rect::new(20, 20, 80, 30));
let a = register(Box::new(a)).expect("registry");
with_widget_mut(parent, |widget| widget.add_child(a));
let mut b = crate::widget::base_widgets::button::Button::new(
"B".to_string(),
Rect::new(130, 20, 80, 30),
);
b.set_geometry(Rect::new(130, 20, 80, 30));
let b = register(Box::new(b)).expect("registry");
with_widget_mut(parent, |widget| widget.add_child(b));
let clicks_a = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let counter_a = std::sync::Arc::clone(&clicks_a);
with_widget_mut(a, |widget| {
widget.base().clicked.connect(move || {
counter_a.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
});
});
let clicks_b = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
let counter_b = std::sync::Arc::clone(&clicks_b);
with_widget_mut(b, |widget| {
widget.base().clicked.connect(move || {
counter_b.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
});
});
assert!(dispatch_pointer_event(
parent,
&Event::MousePress {
pos: Point::new(40, 35),
button: mouse_button::PRIMARY,
modifiers: 0
},
Point::new(40, 35),
));
assert_eq!(capturing_widget(), Some(a), "the pressed control must own the gesture");
dispatch_pointer_event(
parent,
&Event::MouseMove { pos: Point::new(160, 35) },
Point::new(160, 35),
);
assert!(
dispatch_pointer_event(
parent,
&Event::MouseRelease { pos: Point::new(280, 280), button: mouse_button::PRIMARY },
Point::new(280, 280),
),
"the off-widget release must be routed back to the gesture owner, not dropped"
);
assert_eq!(capturing_widget(), None, "the gesture-ending release must release the capture");
assert!(
!with_widget_mut(a, |w| w.base().is_grabbed()).unwrap_or(true),
"A's grab must be cleared by the release that ended its gesture"
);
assert_eq!(clicks_a.load(std::sync::atomic::Ordering::SeqCst), 0);
assert_eq!(clicks_b.load(std::sync::atomic::Ordering::SeqCst), 0);
dispatch_pointer_event(
parent,
&Event::MouseMove { pos: Point::new(40, 35) },
Point::new(40, 35),
);
dispatch_pointer_event(
parent,
&Event::MouseRelease { pos: Point::new(40, 35), button: mouse_button::PRIMARY },
Point::new(40, 35),
);
assert_eq!(
clicks_a.load(std::sync::atomic::Ordering::SeqCst),
0,
"a stray release must not activate a control whose earlier gesture was cancelled"
);
unregister(a);
unregister(b);
unregister(parent);
}
fn modal_fixture() -> (ObjectId, ObjectId, ObjectId) {
let window = register(Box::new(crate::widget::container_widgets::groupbox::GroupBox::new(
Rect::new(0, 0, 400, 400),
)))
.expect("window");
let modal = register(Box::new(crate::widget::dialog::message_box::MessageBox::new(
Rect::new(50, 50, 200, 100),
)))
.expect("modal");
let outside = register(Box::new(crate::widget::base_widgets::label::Label::new(
"outside".to_string(),
Rect::new(0, 0, 100, 20),
)))
.expect("outside");
with_widget_mut(modal, |w| w.set_parent(Some(window)));
with_widget_mut(outside, |w| w.set_parent(Some(window)));
with_widget_mut(window, |w| {
w.add_child(modal);
w.add_child(outside);
});
(window, modal, outside)
}
#[test]
fn no_modal_blocks_nothing() {
let (window, modal, outside) = modal_fixture();
assert!(!is_modal_active());
assert!(!modal_blocks(window));
assert!(!modal_blocks(modal));
assert!(!modal_blocks(outside));
unregister(window);
unregister(modal);
unregister(outside);
}
#[test]
fn an_active_modal_blocks_input_outside_its_subtree() {
let (window, modal, outside) = modal_fixture();
assert!(enter_modal(modal));
assert!(is_modal_active());
assert_eq!(active_modal(), Some(modal));
assert!(!modal_blocks(modal));
assert!(modal_blocks(window));
assert!(modal_blocks(outside));
let event = crate::event::Event::mouse_press(10, 10, 1);
assert!(!dispatch_event(outside, &event), "a blocked widget must not receive events");
assert!(dispatch_event(modal, &event), "the modal dialog must receive events");
exit_modal(modal);
assert!(!is_modal_active());
assert!(!modal_blocks(outside), "after dismissal nothing is blocked");
unregister(window);
unregister(modal);
unregister(outside);
}
#[test]
fn a_modal_blocks_focus_outside_its_subtree() {
let (window, modal, outside) = modal_fixture();
clear_focus();
enter_modal(modal);
assert!(focus_widget(modal));
assert!(!focus_widget(outside));
assert_eq!(focused_widget(), Some(modal));
exit_modal(modal);
assert!(focus_widget(outside));
assert_eq!(focused_widget(), Some(outside));
clear_focus();
unregister(window);
unregister(modal);
unregister(outside);
}
#[test]
fn an_unmounted_modal_cannot_be_entered() {
clear_modals();
assert!(!enter_modal(0xDEAD_BEEF));
assert!(!is_modal_active());
}
#[test]
fn clear_modals_drops_the_whole_stack() {
let (_, modal, _) = modal_fixture();
assert!(enter_modal(modal));
assert!(is_modal_active());
clear_modals();
assert!(!is_modal_active());
unregister(modal);
}
#[derive(Default)]
struct RecordingImeBridge {
calls: crate::compat::Mutex<Vec<(&'static str, ObjectId)>>,
}
impl RecordingImeBridge {
fn calls(&self) -> Vec<(&'static str, ObjectId)> {
self.calls.lock().unwrap().clone()
}
}
impl crate::platform::ime::ImeBridge for RecordingImeBridge {
fn focus_in(&self, widget_id: ObjectId) {
self.calls.lock().unwrap().push(("in", widget_id));
}
fn focus_out(&self, widget_id: ObjectId) {
self.calls.lock().unwrap().push(("out", widget_id));
}
fn commit_text(&self, _text: &str) {}
fn set_composition(&self, _composition: &crate::platform::ime::ImeComposition) {}
fn set_candidate_window_position(
&self,
_position: crate::platform::ime::ImeCandidatePosition,
) {
}
fn is_active(&self) -> bool {
true
}
}
struct A11yRecorder {
names: std::sync::Mutex<Vec<(ObjectId, String)>>,
states: std::sync::Mutex<Vec<ObjectId>>,
nodes: std::sync::Mutex<
std::collections::HashMap<ObjectId, crate::platform::accessibility::A11yState>,
>,
}
impl A11yRecorder {
fn new() -> Self {
Self {
names: std::sync::Mutex::new(Vec::new()),
states: std::sync::Mutex::new(Vec::new()),
nodes: std::sync::Mutex::new(std::collections::HashMap::new()),
}
}
}
impl crate::platform::accessibility::AccessibilityBridge for A11yRecorder {
fn set_accessibility_name(&self, id: ObjectId, name: &str) {
self.names.lock().unwrap().push((id, name.to_string()));
}
fn accessibility_name(&self, id: ObjectId) -> Option<String> {
self.names
.lock()
.unwrap()
.iter()
.rev()
.find(|(recorded, _)| *recorded == id)
.map(|(_, name)| name.clone())
}
fn notify_name_changed(&self, _id: ObjectId) {}
fn notify_value_changed(&self, _id: ObjectId) {}
fn notify_state_changed(&self, id: ObjectId) {
self.states.lock().unwrap().push(id);
}
fn notify_focus_changed(&self, _id: ObjectId) {}
fn submit_node_state(
&self,
id: ObjectId,
state: &crate::platform::accessibility::A11yState,
) {
self.names.lock().unwrap().push((id, state.label.clone()));
self.nodes.lock().unwrap().insert(id, state.clone());
}
fn node_state(&self, id: ObjectId) -> Option<crate::platform::accessibility::A11yState> {
self.nodes.lock().unwrap().get(&id).cloned()
}
fn unregister_node(&self, id: ObjectId) {
self.names.lock().unwrap().retain(|(recorded, _)| *recorded != id);
self.nodes.lock().unwrap().remove(&id);
}
fn node_count(&self) -> usize {
self.nodes.lock().unwrap().len()
}
}
struct A11yGuard;
impl Drop for A11yGuard {
fn drop(&mut self) {
let _ = crate::widget::a11y_submit::uninstall_bridge();
}
}
#[test]
fn mounting_controls_creates_their_nodes() {
let recorder: &'static A11yRecorder = Box::leak(Box::new(A11yRecorder::new()));
crate::widget::a11y_submit::install_bridge(recorder);
let _guard = A11yGuard;
let label = register(Box::new(crate::widget::Label::new(
"Hello".to_string(),
crate::core::Rect::new(0, 0, 80, 24),
)))
.expect("mount a label");
let _unmount_label = MountGuard(label);
let button = register(Box::new(crate::widget::Button::new(
"Save".to_string(),
crate::core::Rect::new(0, 0, 80, 32),
)))
.expect("mount a button");
let _unmount_button = MountGuard(button);
let checkbox =
register(Box::new(crate::widget::CheckBox::new(crate::core::Rect::new(0, 0, 24, 24))))
.expect("mount a check box");
let _unmount_checkbox = MountGuard(checkbox);
let names = recorder.names.lock().unwrap().clone();
assert_eq!(names.len(), 3, "three controls mounted, so three names were pushed: {names:?}");
assert!(
names.iter().any(|(id, name)| *id == label && name == "Hello"),
"a label's accessible name is its text: {names:?}"
);
assert!(
names.iter().any(|(id, name)| *id == button && name == "Save"),
"a button's accessible name is its title: {names:?}"
);
let states = recorder.states.lock().unwrap().clone();
assert_eq!(states.len(), 3, "and each node's creation was reported: {states:?}");
assert_eq!(
recorder.node_state(label).map(|s| s.role),
Some(crate::platform::accessibility::A11yRole::Label),
"a label's role reaches the bridge"
);
assert_eq!(
recorder.node_state(button).map(|s| s.role),
Some(crate::platform::accessibility::A11yRole::Button),
"a button's role reaches the bridge"
);
assert_eq!(
recorder.node_state(checkbox).map(|s| s.role),
Some(crate::platform::accessibility::A11yRole::CheckBox),
"a check box's role reaches the bridge"
);
assert_eq!(
recorder.node_state(checkbox).and_then(|s| s.checked),
Some(false),
"an unchecked box reports `Some(false)`, not `None`"
);
}
#[test]
fn repeated_mount_unmount_returns_the_bridge_store_to_baseline() {
let recorder: &'static A11yRecorder = Box::leak(Box::new(A11yRecorder::new()));
crate::widget::a11y_submit::install_bridge(recorder);
let _guard = A11yGuard;
let baseline = recorder.node_count();
assert_eq!(baseline, 0, "a fresh bridge records no nodes");
for cycle in 0..5 {
let id = register(Box::new(crate::widget::Label::new(
format!("cycle-{cycle}"),
crate::core::Rect::new(0, 0, 80, 24),
)))
.expect("mount");
assert_eq!(recorder.node_count(), baseline + 1, "one live node in cycle {cycle}");
assert!(
recorder.node_state(id).is_some(),
"the mounted node is recorded in cycle {cycle}"
);
assert!(unregister(id), "the mounted id is present in cycle {cycle}");
assert_eq!(
recorder.node_count(),
baseline,
"the store returns to baseline after cycle {cycle}"
);
assert!(
recorder.node_state(id).is_none(),
"and the node itself is gone after cycle {cycle}"
);
}
let names = recorder.names.lock().unwrap();
assert!(names.is_empty(), "no historical id left a blanked name entry behind: {names:?}");
}
#[test]
fn unmounting_a_control_tears_down_its_node() {
let recorder: &'static A11yRecorder = Box::leak(Box::new(A11yRecorder::new()));
crate::widget::a11y_submit::install_bridge(recorder);
let _guard = A11yGuard;
let id = register(Box::new(crate::widget::Label::new(
"Bye".to_string(),
crate::core::Rect::new(0, 0, 80, 24),
)))
.expect("mount");
let before = recorder.states.lock().unwrap().len();
assert!(unregister(id), "the mounted id is present");
let after = recorder.states.lock().unwrap().len();
assert_eq!(after, before + 1, "unmounting posted one teardown");
assert!(!unregister(id), "the id is gone");
assert_eq!(
recorder.states.lock().unwrap().len(),
after,
"an unmount of a never-mounted id must not post a teardown"
);
}
#[test]
fn a_check_boxs_three_states_travel_the_submit_path() {
use crate::platform::accessibility::A11yState;
for (check, expected_checked, expected_mixed) in
[(false, Some(false), false), (true, Some(true), false)]
{
let mut cb = crate::widget::CheckBox::new(crate::core::Rect::new(0, 0, 24, 24));
cb.set_checked(check);
let state = A11yState::from_widget(&cb);
assert_eq!(state.checked, expected_checked, "checked={check}");
assert_eq!(state.mixed, expected_mixed, "checked={check}");
}
let mut cb = crate::widget::CheckBox::new(crate::core::Rect::new(0, 0, 24, 24));
cb.set_tristate_enabled(true);
cb.set_state(crate::widget::CheckState::PartiallyChecked);
let state = A11yState::from_widget(&cb);
assert_eq!(state.checked, Some(true), "a mixed box is on");
assert!(state.mixed, "and separately mixed, which is the only way to say it");
}
#[test]
fn a_reported_hover_reaches_widget_state() {
use crate::style::WidgetState;
let id = register(Box::new(crate::widget::Button::new(
"native".to_string(),
crate::core::Rect::new(0, 0, 80, 32),
)))
.expect("mount");
let _unmount = MountGuard(id);
assert_eq!(
with_widget(id, |w| w.widget_state()),
Some(WidgetState::Normal),
"a freshly mounted control is at rest"
);
assert!(report_state(id, StateFact::Hovered(true)), "the fact reaches a mounted control");
assert_eq!(
with_widget(id, |w| w.widget_state()),
Some(WidgetState::Hover),
"so `widget_state()` is now true for a control the library never saw input for"
);
assert!(report_state(id, StateFact::Hovered(true)), "a known id is still found");
assert_eq!(with_widget(id, |w| w.widget_state()), Some(WidgetState::Hover));
assert!(report_state(id, StateFact::Hovered(false)), "leaving is a fact too");
assert_eq!(with_widget(id, |w| w.widget_state()), Some(WidgetState::Normal));
}
#[test]
fn a_report_about_an_unknown_control_is_refused() {
assert!(!report_state(0xDEAD_BEEF, StateFact::Hovered(true)));
assert!(!report_state(0xDEAD_BEEF, StateFact::Pressed(true)));
}
#[test]
fn a_native_redraw_is_counted_by_the_frame() {
let id = register(Box::new(crate::widget::Label::new(
"n".to_string(),
crate::core::Rect::new(0, 0, 40, 16),
)))
.expect("mount");
let _unmount = MountGuard(id);
let _ = drive_frame(0);
notify_native_redraw(id, Some(crate::core::Rect::new(0, 0, 10, 10)));
let outcome = drive_frame(0);
assert_eq!(
outcome.repaints_submitted, 1,
"the platform's own redraw request is in the library's account"
);
}
#[test]
fn sixty_still_frames_cost_nothing() {
let id = register(Box::new(crate::widget::Label::new(
"still".to_string(),
crate::core::Rect::new(0, 0, 40, 16),
)))
.expect("mount");
let _unmount = MountGuard(id);
for _ in 0..60 {
let outcome = drive_frame(16);
assert_eq!(outcome.controls_ticked, 0, "nothing is animating");
let stats = last_frame_stats().expect("a frame ran");
assert_eq!(stats.controls_ticked, 0);
assert_eq!(
stats.repaints_coalesced, 0,
"nothing was requested, so nothing could be merged"
);
assert!(stats.last_repaint_reason.is_empty(), "and no surface was repainted");
}
}
#[test]
fn a_control_that_stops_animating_lets_the_frame_loop_sleep() {
use crate::widget::display_widgets::progressbar::ProgressBar;
let mut bar = ProgressBar::new(crate::core::Rect::new(0, 0, 160, 16));
bar.set_indeterminate(true);
let id = register(Box::new(bar)).expect("mount");
let _unmount = MountGuard(id);
let running = drive_frame(16);
assert_eq!(running.controls_ticked, 1);
assert!(running.needs_another_frame, "an animating control keeps the loop awake");
with_widget_mut(id, |widget| {
if let Some(bar) =
crate::widget::capability::coercion::widget_as_mut::<ProgressBar>(widget)
{
bar.set_indeterminate(false);
}
});
let settled = drive_frame(16);
assert_eq!(settled.controls_ticked, 0, "nothing is animating now");
let after = drive_frame(16);
assert!(
!after.needs_another_frame,
"a window whose animation has settled must stop being scheduled"
);
assert_eq!(after.controls_ticked, 0);
assert_eq!(after.repaints_submitted, 0, "and a still frame costs no submission");
}
#[test]
fn a_playing_media_player_advances_through_the_frame_loop() {
use crate::widget::special_widgets::media_player::MediaPlayer;
let mut player = MediaPlayer::new(crate::core::Rect::new(0, 0, 320, 200));
player.set_source("clip.mp4", 1_000);
assert!(player.play());
let id = register(Box::new(player)).expect("mount");
let _unmount = MountGuard(id);
let outcome = drive_frame(16);
assert_eq!(outcome.controls_ticked, 1, "the player is the one control animating");
assert!(outcome.needs_another_frame, "a playing player keeps the loop awake");
assert_eq!(
with_widget(id, |widget| widget.is_animating()),
Some(true),
"and it says so through the trait, not only through its own methods"
);
let mut stopped_at = None;
for frame in 1..=120 {
let outcome = drive_frame(16);
if !outcome.needs_another_frame {
stopped_at = Some(frame);
break;
}
}
assert!(
stopped_at.is_some(),
"playback must end on its own, not keep the frame loop awake for ever"
);
let stats = last_frame_stats().expect("a frame ran");
assert_eq!(
stats.controls_ticked, 0,
"the frame that observed the end no longer ticks the player"
);
}
#[test]
fn one_surface_is_submitted_once_and_the_rest_are_coalesced() {
let surface = register(Box::new(crate::widget::Label::new(
"s".to_string(),
crate::core::Rect::new(0, 0, 40, 16),
)))
.expect("mount");
let _unmount = MountGuard(surface);
let _ = drive_frame(0);
for _ in 0..5 {
notify_native_redraw(surface, None);
}
let outcome = drive_frame(0);
assert_eq!(outcome.repaints_submitted, 1, "one surface, one submission");
let stats = last_frame_stats().expect("a frame ran");
assert_eq!(stats.repaints_coalesced, 4, "and the other four were merged into it");
}
#[test]
fn every_repaint_names_a_reason() {
let id = register(Box::new(crate::widget::Button::new(
"why".to_string(),
crate::core::Rect::new(0, 0, 80, 32),
)))
.expect("mount");
let _unmount = MountGuard(id);
let _ = drive_frame(0);
notify_native_redraw(id, None);
let _ = drive_frame(0);
let stats = last_frame_stats().expect("a frame ran");
assert!(
!stats.last_repaint_reason.is_empty(),
"a frame that submitted a repaint must be able to say why"
);
assert_eq!(
stats.last_repaint_reason.iter().find(|(sid, _)| *sid == id).map(|(_, r)| *r),
Some(RepaintReason::Native),
"a platform redraw is attributed to the platform: {:?}",
stats.last_repaint_reason
);
}
#[test]
fn two_causes_on_one_surface_record_the_first() {
use crate::platform::{with_recorded_invalidations, RecordingInvalidations};
let recorder: &'static RecordingInvalidations =
Box::leak(Box::new(RecordingInvalidations::default()));
with_recorded_invalidations(recorder, || {
let id = register(Box::new(crate::widget::Button::new(
"first".to_string(),
crate::core::Rect::new(0, 0, 80, 32),
)))
.expect("mount");
let _unmount = MountGuard(id);
let _ = drive_frame(0);
request_repaint_because(id, RepaintReason::Animation);
request_repaint_because(id, RepaintReason::State);
let outcome = drive_frame(0);
assert_eq!(outcome.repaints_submitted, 1, "one surface, one submission");
let stats = last_frame_stats().expect("a frame ran");
assert_eq!(stats.repaints_coalesced, 1, "and the second request was merged");
assert_eq!(
stats.last_repaint_reason.iter().find(|(sid, _)| *sid == id).map(|(_, r)| *r),
Some(RepaintReason::Animation),
"the cause that made the frame happen is the one recorded"
);
});
}
#[test]
fn only_animation_keeps_asking_for_frames() {
assert!(RepaintReason::Animation.keeps_animating());
assert!(!RepaintReason::State.keeps_animating());
assert!(!RepaintReason::Overlay.keeps_animating());
assert!(!RepaintReason::Explicit.keeps_animating());
assert!(!RepaintReason::Native.keeps_animating());
}
#[test]
fn a_window_tree_frame_contains_its_children_not_just_the_background() {
let window_id = register(Box::new(crate::widget::window::Window::new(
"t".to_string(),
Rect::new(0, 0, 200, 120),
)))
.expect("mount the window");
let _unmount_window = MountGuard(window_id);
let child_id = register(Box::new(crate::widget::Button::new(
"ok".to_string(),
Rect::new(10, 40, 80, 32),
)))
.expect("mount the button");
let _unmount_child = MountGuard(child_id);
assert!(with_widget_mut(window_id, |window| {
window.add_child(child_id);
true
})
.unwrap_or(false));
let clear = Color::rgb(255, 255, 255);
let frame = render_frame_tree(window_id, Size::new(200, 120), clear)
.expect("a window with a drawable child must produce a frame");
let clear_rgba = [clear.r, clear.g, clear.b, 255];
let painted = frame.as_chunks::<4>().0.iter().filter(|pixel| **pixel != clear_rgba).count();
assert!(
painted > 0,
"the window's own chrome or its child must paint something; \
a uniform frame is the blank-board defect"
);
}
#[test]
fn a_mounted_child_is_reachable_through_the_window_child_list() {
let window_id = register(Box::new(crate::widget::window::Window::new(
"t".to_string(),
Rect::new(0, 0, 200, 120),
)))
.expect("mount the window");
let _unmount_window = MountGuard(window_id);
let child_id = register(Box::new(crate::widget::Button::new(
"ok".to_string(),
Rect::new(5, 5, 40, 20),
)))
.expect("mount the button");
let _unmount_child = MountGuard(child_id);
assert!(
!direct_children_of(window_id).contains(&child_id),
"the premise: mounting a child does not by itself enlist it with the window"
);
assert!(with_widget_mut(window_id, |window| {
window.add_child(child_id);
true
})
.unwrap_or(false));
assert!(
direct_children_of(window_id).contains(&child_id),
"after `add_child` the window painter must be able to find it"
);
}
#[test]
fn a_container_resize_reaches_a_nested_child() {
let window_id = register(Box::new(crate::widget::window::Window::new(
"t".to_string(),
Rect::new(0, 0, 200, 120),
)))
.expect("mount the window");
let _unmount_window = MountGuard(window_id);
let panel_id = register(Box::new(crate::widget::Panel::new(Rect::new(0, 0, 200, 120))))
.expect("mount the panel");
let _unmount_panel = MountGuard(panel_id);
with_widget_mut(window_id, |window| window.add_child(panel_id));
let editor_id = register(Box::new(crate::widget::Button::new(
"ok".to_string(),
Rect::new(0, 0, 40, 20),
)))
.expect("mount the button");
let _unmount_editor = MountGuard(editor_id);
with_widget_mut(panel_id, |panel| panel.add_child(editor_id));
let reached = dispatch_resize(window_id, 640, 480);
assert_eq!(reached, 3, "window + panel + button");
assert_eq!(dispatch_resize(u64::MAX, 10, 10), 0);
}
#[test]
fn a_click_callback_may_update_other_widgets_without_panicking() {
use crate::core::Point;
use crate::event::mouse_button;
let button_id = register(Box::new(crate::widget::Button::new(
"go".to_string(),
Rect::new(0, 0, 60, 24),
)))
.expect("mount the button");
let _button_guard = MountGuard(button_id);
let label_id = register(Box::new(crate::widget::Label::new(
"before".to_string(),
Rect::new(0, 0, 80, 20),
)))
.expect("mount the label");
let _label_guard = MountGuard(label_id);
let ran = std::sync::Arc::new(core::sync::atomic::AtomicBool::new(false));
let ran_slot = std::sync::Arc::clone(&ran);
with_widget_mut(button_id, |button| {
button.base_mut().clicked.connect(move || {
assert!(set_geometry(label_id, Rect::new(5, 5, 120, 20)));
let _ = with_widget(label_id, |_| ());
ran_slot.store(true, core::sync::atomic::Ordering::SeqCst);
});
});
dispatch_event(
button_id,
&crate::event::Event::MousePress {
pos: Point::new(10, 10),
button: mouse_button::PRIMARY,
modifiers: 0,
},
);
dispatch_event(
button_id,
&crate::event::Event::MouseRelease {
pos: Point::new(10, 10),
button: mouse_button::PRIMARY,
},
);
assert!(
ran.load(core::sync::atomic::Ordering::SeqCst),
"the click callback must have run to completion rather than panicking"
);
assert_eq!(with_widget(label_id, |label| label.geometry().width), Some(120));
}
#[test]
fn a_callback_may_destroy_the_widget_it_is_handling() {
use crate::core::Point;
use crate::event::mouse_button;
let button_id = register(Box::new(crate::widget::Button::new(
"self-destruct".to_string(),
Rect::new(0, 0, 80, 24),
)))
.expect("mount the button");
let self_id = button_id;
with_widget_mut(button_id, |button| {
button.base_mut().clicked.connect(move || {
assert!(unregister(self_id), "the handler's unregister must take effect");
});
});
dispatch_event(
button_id,
&crate::event::Event::MousePress {
pos: Point::new(10, 10),
button: mouse_button::PRIMARY,
modifiers: 0,
},
);
dispatch_event(
button_id,
&crate::event::Event::MouseRelease {
pos: Point::new(10, 10),
button: mouse_button::PRIMARY,
},
);
assert!(
!is_mounted(button_id),
"the widget must not be resurrected by the dispatch epilogue"
);
}
#[test]
fn a_property_write_callback_may_read_the_registry_without_panicking() {
use crate::widget::capability::access::write_widget_property_by_id;
use crate::widget::capability::CapabilityValue;
use crate::widget::Slider;
let slider_id = register(Box::new(Slider::new(Rect::new(0, 0, 200, 30)))).expect("mount");
let _guard = MountGuard(slider_id);
let other_id = register(Box::new(crate::widget::Label::new(
"other".to_string(),
Rect::new(0, 0, 60, 20),
)))
.expect("mount the label");
let _other_guard = MountGuard(other_id);
let observed = std::sync::Arc::new(std::sync::Mutex::new(None::<(bool, bool)>));
let observed_slot = std::sync::Arc::clone(&observed);
with_widget_mut(slider_id, |widget| {
let reference = widget.event_signal_dyn("value_changed").expect("published");
reference.subscribe(Box::new(move |_payload| {
let other_is_readable = geometry_of(other_id).is_some();
let self_is_readable = geometry_of(slider_id).is_some();
*observed_slot.lock().expect("lock") = Some((other_is_readable, self_is_readable));
}));
});
write_widget_property_by_id(slider_id, "value", CapabilityValue::Int(42))
.expect("the slider accepts a value write");
assert_eq!(
*observed.lock().expect("lock"),
Some((true, false)),
"the callback may read other widgets, but must not alias the widget still held mutably"
);
}
#[test]
fn a_property_write_callback_may_destroy_the_control() {
use crate::widget::capability::access::write_widget_property_by_id;
use crate::widget::capability::CapabilityValue;
use crate::widget::Slider;
let slider_id = register(Box::new(Slider::new(Rect::new(0, 0, 200, 30)))).expect("mount");
let self_id = slider_id;
with_widget_mut(slider_id, |widget| {
let reference = widget.event_signal_dyn("value_changed").expect("published");
reference.subscribe(Box::new(move |_payload| {
assert!(unregister(self_id), "the callback's unregister must take effect");
}));
});
write_widget_property_by_id(slider_id, "value", CapabilityValue::Int(7))
.expect("the slider accepts a value write");
assert!(
!is_mounted(slider_id),
"a destroy during a property write must not be undone by the drive's reinsertion"
);
}
#[test]
fn a_callback_does_not_alias_a_widget_while_it_is_mutably_driven() {
use crate::core::Point;
use crate::event::mouse_button;
let button_id = register(Box::new(crate::widget::Button::new(
"go".to_string(),
Rect::new(0, 0, 80, 24),
)))
.expect("mount the button");
let _guard = MountGuard(button_id);
let self_read = std::sync::Arc::new(std::sync::Mutex::new(None::<(bool, bool)>));
let record = std::sync::Arc::clone(&self_read);
with_widget_mut(button_id, |button| {
button.base_mut().clicked.connect(move || {
let mounted_by_registry_id = is_mounted(button_id);
let geometry = geometry_of(button_id);
*record.lock().expect("lock") = Some((mounted_by_registry_id, geometry.is_some()));
});
});
dispatch_event(
button_id,
&crate::event::Event::MousePress {
pos: Point::new(10, 10),
button: mouse_button::PRIMARY,
modifiers: 0,
},
);
dispatch_event(
button_id,
&crate::event::Event::MouseRelease {
pos: Point::new(10, 10),
button: mouse_button::PRIMARY,
},
);
let observed = *self_read.lock().expect("lock");
assert_eq!(
observed,
Some((true, false)),
"a callback must see the control as mounted without creating an aliased shared reference"
);
}
#[test]
fn a_panicking_input_callback_leaves_no_stale_dispatch_state() {
use crate::core::Point;
use crate::event::mouse_button;
let button_id = register(Box::new(crate::widget::Button::new(
"boom".to_string(),
Rect::new(0, 0, 80, 24),
)))
.expect("mount the button");
let _unmount = MountGuard(button_id);
with_widget_mut(button_id, |button| {
button.base_mut().clicked.connect(|| {
panic!("deliberate unwind from an input callback");
});
});
let press = crate::event::Event::MousePress {
pos: Point::new(10, 10),
button: mouse_button::PRIMARY,
modifiers: 0,
};
let release = crate::event::Event::MouseRelease {
pos: Point::new(10, 10),
button: mouse_button::PRIMARY,
};
let caught = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
dispatch_event(button_id, &press);
dispatch_event(button_id, &release);
}));
assert!(caught.is_err(), "the callback must have unwound");
assert!(
!is_mounted(button_id),
"the lookup must not resolve a widget dropped by the unwind"
);
assert!(
!unregister(button_id),
"a popped dispatch must not report the id as present via a leftover in-flight marker"
);
}
#[test]
fn a_read_closure_may_emit_a_signal_whose_callback_writes_another_control() {
let a_id = register(Box::new(crate::widget::Button::new(
"a".to_string(),
Rect::new(0, 0, 60, 24),
)))
.expect("mount A");
let _a_guard = MountGuard(a_id);
let b_id = register(Box::new(crate::widget::Label::new(
"before".to_string(),
Rect::new(0, 0, 80, 20),
)))
.expect("mount B");
let _b_guard = MountGuard(b_id);
let ran = std::sync::Arc::new(core::sync::atomic::AtomicBool::new(false));
let ran_slot = std::sync::Arc::clone(&ran);
with_widget_mut(a_id, |widget| {
widget.base_mut().clicked.connect(move || {
assert!(set_geometry(b_id, Rect::new(3, 4, 120, 20)));
ran_slot.store(true, core::sync::atomic::Ordering::SeqCst);
});
});
let result = with_widget(a_id, |widget| {
widget.base().clicked.emit();
widget.geometry().width
});
assert_eq!(result, Some(60), "the read closure must return normally, not panic");
assert!(
ran.load(core::sync::atomic::Ordering::SeqCst),
"the slot must have run and written the other control without a RefCell panic"
);
assert_eq!(with_widget(b_id, |label| label.geometry().width), Some(120));
}
#[test]
fn unregister_during_a_read_loan_is_not_undone_by_reinsertion() {
let id = register(Box::new(crate::widget::Label::new(
"remove".to_string(),
Rect::new(0, 0, 60, 20),
)))
.expect("mount");
let removed = with_widget(id, |_| unregister(id));
assert_eq!(removed, Some(true), "unregister must see the in-flight read loan");
assert!(!is_mounted(id), "the read-loan epilogue must not resurrect the widget");
assert!(!unregister(id), "the id must already be fully unregistered");
}
#[test]
fn a_widget_window_id_round_trips_through_its_host_id() {
let widget = register(Box::new(crate::widget::Label::new(
"win".to_string(),
Rect::new(0, 0, 100, 80),
)))
.expect("mount");
let _unmount = MountGuard(widget);
let host: ObjectId = 7;
assert!(set_host_window(widget, host), "a mounted window must accept a host association");
assert_eq!(host_window_for(widget), Some(host), "window -> host");
assert_eq!(widget_id_for_host_window(host), Some(widget), "host -> window");
assert_eq!(host_window_for(host), None, "a host id is not itself a widget");
assert_eq!(widget_id_for_host_window(widget), None, "a widget id is not a host id");
}
#[test]
fn unmounting_a_window_clears_its_host_association() {
let widget = register(Box::new(crate::widget::Label::new(
"win".to_string(),
Rect::new(0, 0, 100, 80),
)))
.expect("mount");
let host: ObjectId = 99;
assert!(set_host_window(widget, host));
assert_eq!(widget_id_for_host_window(host), Some(widget));
unregister(widget);
assert_eq!(host_window_for(widget), None, "the mapping must not outlive the widget");
assert_eq!(
widget_id_for_host_window(host),
None,
"a later widget reusing this host id must not resolve to the dead one"
);
}
#[test]
fn set_host_window_refuses_an_unmounted_id() {
let ghost: ObjectId = 0x5345_4C46_DEAD_BEEF;
assert!(!set_host_window(ghost, 1), "only a mounted window may carry a host id");
assert_eq!(host_window_for(ghost), None);
}
}