use std::collections::{BTreeMap, HashMap};
use std::error::Error;
use std::fmt;
use std::sync::Arc;
use whisker_protocol::{
Accessibility, BackgroundLayer, BoxClip, BoxPaint, CommandId, Cursor, ElementTypeId,
FrameHeader, FrameMode, FramePacket, HitTestBehavior, LayoutGeometry, NodeId, Operation,
PointerId, PropertyId, ProtocolVersion, SurfaceId, TextContent, TextContentError,
TextStyleSnapshot, Transform, Visibility, VisualEffects, WhiskerValue,
};
#[cfg(test)]
use whisker_protocol::{InputPoint, OverflowClip};
mod hit_test;
#[derive(Clone, Debug, PartialEq)]
pub struct SceneNode {
element_type: ElementTypeId,
parent: Option<NodeId>,
children: Vec<NodeId>,
layout: Option<LayoutGeometry>,
box_paint: Option<BoxPaint>,
background_layers: Vec<BackgroundLayer>,
visual_effects: VisualEffects,
clip: Option<BoxClip>,
transform: Option<Transform>,
opacity: Option<f32>,
visibility: Option<Visibility>,
z_order: Option<i32>,
text: Option<TextContent>,
text_style: Option<TextStyleSnapshot>,
accessibility: Option<Accessibility>,
properties: BTreeMap<PropertyId, WhiskerValue>,
event_mask: Option<u64>,
hit_test: Option<HitTestBehavior>,
cursor: Option<Cursor>,
host_scroll_offset: [f32; 2],
}
impl SceneNode {
fn new(element_type: ElementTypeId) -> Self {
Self {
element_type,
parent: None,
children: Vec::new(),
layout: None,
box_paint: None,
background_layers: Vec::new(),
visual_effects: VisualEffects::default(),
clip: None,
transform: None,
opacity: None,
visibility: None,
z_order: None,
text: None,
text_style: None,
accessibility: None,
properties: BTreeMap::new(),
event_mask: None,
hit_test: None,
cursor: None,
host_scroll_offset: [0.0; 2],
}
}
pub const fn element_type(&self) -> ElementTypeId {
self.element_type
}
pub const fn parent(&self) -> Option<NodeId> {
self.parent
}
pub fn children(&self) -> &[NodeId] {
&self.children
}
pub const fn layout(&self) -> Option<LayoutGeometry> {
self.layout
}
pub const fn text(&self) -> Option<&TextContent> {
self.text.as_ref()
}
pub const fn text_style(&self) -> Option<&TextStyleSnapshot> {
self.text_style.as_ref()
}
pub const fn accessibility(&self) -> Option<&Accessibility> {
self.accessibility.as_ref()
}
pub const fn box_paint(&self) -> Option<&BoxPaint> {
self.box_paint.as_ref()
}
pub fn background_layers(&self) -> &[BackgroundLayer] {
&self.background_layers
}
pub const fn visual_effects(&self) -> &VisualEffects {
&self.visual_effects
}
pub const fn clip(&self) -> Option<BoxClip> {
self.clip
}
pub const fn transform(&self) -> Option<Transform> {
self.transform
}
pub const fn opacity(&self) -> Option<f32> {
self.opacity
}
pub const fn visibility(&self) -> Option<Visibility> {
self.visibility
}
pub const fn z_order(&self) -> Option<i32> {
self.z_order
}
pub const fn event_mask(&self) -> Option<u64> {
self.event_mask
}
pub const fn hit_test(&self) -> Option<HitTestBehavior> {
self.hit_test
}
pub const fn cursor(&self) -> Option<&Cursor> {
self.cursor.as_ref()
}
pub const fn host_scroll_offset(&self) -> [f32; 2] {
self.host_scroll_offset
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum SceneError {
FramePending,
NoPendingFrame,
AcceptedRevisionMismatch {
expected: u64,
received: u64,
},
UnknownNode {
node: NodeId,
},
ChildAlreadyAttached {
child: NodeId,
parent: NodeId,
},
NotDirectChild {
parent: NodeId,
child: NodeId,
},
ChildIndexOutOfBounds {
parent: NodeId,
index: u32,
len: usize,
},
TreeCycle {
parent: NodeId,
child: NodeId,
},
InvalidOpacity {
opacity: f32,
},
NonFiniteNumber,
InvalidText {
error: TextContentError,
},
InvalidBoxPaint,
InvalidBackgroundLayers,
InvalidVisualEffects,
NodeIdExhausted,
RevisionExhausted,
FrameIdExhausted,
SceneEpochExhausted,
}
impl fmt::Display for SceneError {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Whisker scene error: {self:?}")
}
}
impl Error for SceneError {}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
enum DirtySlot {
Layout(NodeId),
BoxPaint(NodeId),
BackgroundLayers(NodeId),
VisualEffects(NodeId),
Clip(NodeId),
Transform(NodeId),
Opacity(NodeId),
Visibility(NodeId),
ZOrder(NodeId),
Text(NodeId),
TextStyle(NodeId),
Accessibility(NodeId),
Property(NodeId, PropertyId),
EventMask(NodeId),
HitTest(NodeId),
Cursor(NodeId),
Pointer(NodeId, PointerId),
}
#[derive(Clone, Debug, Default)]
struct ChangeJournal {
operations: Vec<Operation>,
coalesced: HashMap<DirtySlot, usize>,
}
impl ChangeJournal {
fn push_barrier(&mut self, operation: Operation) {
self.coalesced.clear();
self.operations.push(operation);
}
fn push_coalesced(&mut self, slot: DirtySlot, operation: Operation) {
if let Some(index) = self.coalesced.get(&slot).copied() {
self.operations[index] = operation;
} else {
let index = self.operations.len();
self.operations.push(operation);
self.coalesced.insert(slot, index);
}
}
fn clear(&mut self) {
self.operations.clear();
self.coalesced.clear();
}
}
#[derive(Clone, Debug)]
pub struct Scene {
surface: SurfaceId,
protocol: ProtocolVersion,
scene_epoch: u32,
accepted_revision: u64,
next_node_id: u64,
next_frame_id: u64,
needs_snapshot: bool,
nodes: BTreeMap<NodeId, Arc<SceneNode>>,
pointer_captures: BTreeMap<PointerId, NodeId>,
journal: ChangeJournal,
pending: Option<FramePacket>,
}
impl Scene {
pub fn new(surface: SurfaceId) -> Self {
Self::with_protocol(surface, ProtocolVersion::CURRENT)
}
pub fn with_protocol(surface: SurfaceId, protocol: ProtocolVersion) -> Self {
Self {
surface,
protocol,
scene_epoch: 1,
accepted_revision: 0,
next_node_id: 1,
next_frame_id: 1,
needs_snapshot: true,
nodes: BTreeMap::new(),
pointer_captures: BTreeMap::new(),
journal: ChangeJournal::default(),
pending: None,
}
}
pub const fn surface(&self) -> SurfaceId {
self.surface
}
pub const fn scene_epoch(&self) -> u32 {
self.scene_epoch
}
pub const fn accepted_revision(&self) -> u64 {
self.accepted_revision
}
pub fn node_count(&self) -> usize {
self.nodes.len()
}
pub fn node(&self, node: NodeId) -> Option<&SceneNode> {
self.nodes.get(&node).map(Arc::as_ref)
}
pub fn pointer_capture_target(&self, pointer: PointerId) -> Option<NodeId> {
self.pointer_captures.get(&pointer).copied()
}
#[cfg(test)]
pub(crate) fn set_scene_epoch_for_tests(&mut self, scene_epoch: u32) {
self.scene_epoch = scene_epoch;
}
pub fn has_pending_work(&self) -> bool {
self.pending.is_some() || self.needs_snapshot || !self.journal.operations.is_empty()
}
pub fn has_prepared_frame(&self) -> bool {
self.pending.is_some()
}
pub fn create_node(&mut self, element_type: ElementTypeId) -> Result<NodeId, SceneError> {
self.ensure_mutable()?;
let node = NodeId::new(self.next_node_id).ok_or(SceneError::NodeIdExhausted)?;
self.next_node_id = self.next_node_id.checked_add(1).unwrap_or(0);
self.nodes
.insert(node, Arc::new(SceneNode::new(element_type)));
self.journal
.push_barrier(Operation::CreateNode { node, element_type });
Ok(node)
}
pub fn delete_node(&mut self, node: NodeId) -> Result<(), SceneError> {
self.ensure_mutable()?;
let state = self.require_node(node)?.clone();
if let Some(parent) = state.parent {
self.nodes
.get_mut(&parent)
.map(Arc::make_mut)
.expect("attached parent remains live")
.children
.retain(|candidate| *candidate != node);
}
let mut pending = vec![node];
while let Some(current) = pending.pop() {
let removed = self
.nodes
.remove(¤t)
.expect("retained subtree is internally complete");
pending.extend(removed.children.iter().copied());
}
self.pointer_captures
.retain(|_, target| self.nodes.contains_key(target));
self.journal.push_barrier(Operation::DeleteNode { node });
Ok(())
}
pub fn insert_child(
&mut self,
parent: NodeId,
child: NodeId,
index: u32,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
let len = self.require_node(parent)?.children.len();
let child_state = self.require_node(child)?;
if let Some(existing) = child_state.parent {
return Err(SceneError::ChildAlreadyAttached {
child,
parent: existing,
});
}
if parent == child || self.is_descendant(child, parent) {
return Err(SceneError::TreeCycle { parent, child });
}
let index = index as usize;
if index > len {
return Err(SceneError::ChildIndexOutOfBounds {
parent,
index: index as u32,
len,
});
}
self.nodes
.get_mut(&parent)
.map(Arc::make_mut)
.expect("parent checked above")
.children
.insert(index, child);
self.nodes
.get_mut(&child)
.map(Arc::make_mut)
.expect("child checked above")
.parent = Some(parent);
self.journal.push_barrier(Operation::InsertChild {
parent,
child,
index: index as u32,
});
Ok(())
}
pub fn remove_child(&mut self, parent: NodeId, child: NodeId) -> Result<(), SceneError> {
self.ensure_mutable()?;
self.require_direct_child(parent, child)?;
let children = &mut self
.nodes
.get_mut(&parent)
.map(Arc::make_mut)
.expect("parent checked above")
.children;
let position = children
.iter()
.position(|candidate| *candidate == child)
.expect("parent link and child list agree");
children.remove(position);
self.nodes
.get_mut(&child)
.map(Arc::make_mut)
.expect("child checked above")
.parent = None;
self.journal
.push_barrier(Operation::RemoveChild { parent, child });
Ok(())
}
pub fn move_child(
&mut self,
parent: NodeId,
child: NodeId,
index: u32,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
self.require_direct_child(parent, child)?;
let children = &mut self
.nodes
.get_mut(&parent)
.map(Arc::make_mut)
.expect("parent checked above")
.children;
let old_index = children
.iter()
.position(|candidate| *candidate == child)
.expect("parent link and child list agree");
children.remove(old_index);
let index = index as usize;
if index > children.len() {
children.insert(old_index, child);
return Err(SceneError::ChildIndexOutOfBounds {
parent,
index: index as u32,
len: children.len() - 1,
});
}
children.insert(index, child);
self.journal.push_barrier(Operation::MoveChild {
parent,
child,
index: index as u32,
});
Ok(())
}
pub fn set_layout(
&mut self,
node: NodeId,
geometry: impl Into<LayoutGeometry>,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
let geometry = geometry.into();
if !geometry.is_valid() {
return Err(SceneError::NonFiniteNumber);
}
if self.require_node(node)?.layout == Some(geometry) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.layout = Some(geometry);
self.journal.push_coalesced(
DirtySlot::Layout(node),
Operation::SetLayout { node, geometry },
);
Ok(())
}
pub fn set_box_paint(&mut self, node: NodeId, paint: BoxPaint) -> Result<(), SceneError> {
self.ensure_mutable()?;
if !paint.validate() {
return Err(SceneError::InvalidBoxPaint);
}
if self.require_node(node)?.box_paint.as_ref() == Some(&paint) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.box_paint = Some(paint.clone());
self.journal.push_coalesced(
DirtySlot::BoxPaint(node),
Operation::SetBoxPaint { node, paint },
);
Ok(())
}
pub fn set_background_layers(
&mut self,
node: NodeId,
layers: Vec<BackgroundLayer>,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
if !layers.iter().all(BackgroundLayer::validate) {
return Err(SceneError::InvalidBackgroundLayers);
}
if self.require_node(node)?.background_layers == layers {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.background_layers = layers.clone();
self.journal.push_coalesced(
DirtySlot::BackgroundLayers(node),
Operation::SetBackgroundLayers { node, layers },
);
Ok(())
}
pub fn set_visual_effects(
&mut self,
node: NodeId,
effects: VisualEffects,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
if !effects.validate() {
return Err(SceneError::InvalidVisualEffects);
}
if self.require_node(node)?.visual_effects == effects {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.visual_effects = effects.clone();
self.journal.push_coalesced(
DirtySlot::VisualEffects(node),
Operation::SetVisualEffects { node, effects },
);
Ok(())
}
pub fn set_clip(&mut self, node: NodeId, clip: BoxClip) -> Result<(), SceneError> {
self.ensure_mutable()?;
if self.require_node(node)?.clip == Some(clip) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.clip = Some(clip);
self.journal
.push_coalesced(DirtySlot::Clip(node), Operation::SetClip { node, clip });
Ok(())
}
pub fn set_transform(&mut self, node: NodeId, transform: Transform) -> Result<(), SceneError> {
self.ensure_mutable()?;
if !transform.0.into_iter().all(f32::is_finite) {
return Err(SceneError::NonFiniteNumber);
}
if self.require_node(node)?.transform == Some(transform) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.transform = Some(transform);
self.journal.push_coalesced(
DirtySlot::Transform(node),
Operation::SetTransform { node, transform },
);
Ok(())
}
pub fn set_opacity(&mut self, node: NodeId, opacity: f32) -> Result<(), SceneError> {
self.ensure_mutable()?;
if !opacity.is_finite() || !(0.0..=1.0).contains(&opacity) {
return Err(SceneError::InvalidOpacity { opacity });
}
if self.require_node(node)?.opacity == Some(opacity) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.opacity = Some(opacity);
self.journal.push_coalesced(
DirtySlot::Opacity(node),
Operation::SetOpacity { node, opacity },
);
Ok(())
}
pub fn set_visibility(
&mut self,
node: NodeId,
visibility: Visibility,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
if self.require_node(node)?.visibility == Some(visibility) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.visibility = Some(visibility);
self.journal.push_coalesced(
DirtySlot::Visibility(node),
Operation::SetVisibility { node, visibility },
);
Ok(())
}
pub fn set_z_order(&mut self, node: NodeId, z_order: i32) -> Result<(), SceneError> {
self.ensure_mutable()?;
if self.require_node(node)?.z_order == Some(z_order) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.z_order = Some(z_order);
self.journal.push_coalesced(
DirtySlot::ZOrder(node),
Operation::SetZOrder { node, z_order },
);
Ok(())
}
pub fn set_text(&mut self, node: NodeId, content: TextContent) -> Result<(), SceneError> {
self.ensure_mutable()?;
content
.validate()
.map_err(|error| SceneError::InvalidText { error })?;
if self.require_node(node)?.text.as_ref() == Some(&content) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.text = Some(content.clone());
self.journal
.push_coalesced(DirtySlot::Text(node), Operation::SetText { node, content });
Ok(())
}
pub fn set_text_style(
&mut self,
node: NodeId,
style: TextStyleSnapshot,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
style
.validate()
.map_err(|error| SceneError::InvalidText { error })?;
if self.require_node(node)?.text_style.as_ref() == Some(&style) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.text_style = Some(style.clone());
self.journal.push_coalesced(
DirtySlot::TextStyle(node),
Operation::SetTextStyle { node, style },
);
Ok(())
}
pub fn set_property(
&mut self,
node: NodeId,
property: PropertyId,
value: WhiskerValue,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
if self.require_node(node)?.properties.get(&property) == Some(&value) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.properties
.insert(property, value.clone());
self.journal.push_coalesced(
DirtySlot::Property(node, property),
Operation::SetProperty {
node,
property,
value,
},
);
Ok(())
}
pub fn clear_property(&mut self, node: NodeId, property: PropertyId) -> Result<(), SceneError> {
self.ensure_mutable()?;
if self
.nodes
.get_mut(&node)
.map(Arc::make_mut)
.ok_or(SceneError::UnknownNode { node })?
.properties
.remove(&property)
.is_none()
{
return Ok(());
}
self.journal.push_coalesced(
DirtySlot::Property(node, property),
Operation::ClearProperty { node, property },
);
Ok(())
}
pub fn set_event_mask(&mut self, node: NodeId, event_mask: u64) -> Result<(), SceneError> {
self.ensure_mutable()?;
if self.require_node(node)?.event_mask == Some(event_mask) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.event_mask = Some(event_mask);
self.journal.push_coalesced(
DirtySlot::EventMask(node),
Operation::SetEventMask { node, event_mask },
);
Ok(())
}
pub fn set_accessibility(
&mut self,
node: NodeId,
accessibility: Accessibility,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
if self.require_node(node)?.accessibility.as_ref() == Some(&accessibility) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.accessibility = Some(accessibility.clone());
self.journal.push_coalesced(
DirtySlot::Accessibility(node),
Operation::SetAccessibility {
node,
accessibility,
},
);
Ok(())
}
pub fn set_hit_test(
&mut self,
node: NodeId,
behavior: HitTestBehavior,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
if self.require_node(node)?.hit_test == Some(behavior) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.hit_test = Some(behavior);
self.journal.push_coalesced(
DirtySlot::HitTest(node),
Operation::SetHitTest { node, behavior },
);
Ok(())
}
pub fn update_host_scroll_offset(
&mut self,
node: NodeId,
offset: [f32; 2],
) -> Result<(), SceneError> {
if !offset.into_iter().all(f32::is_finite) {
return Err(SceneError::NonFiniteNumber);
}
self.require_node(node)?;
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.host_scroll_offset = offset;
Ok(())
}
pub fn set_cursor(&mut self, node: NodeId, cursor: Cursor) -> Result<(), SceneError> {
self.ensure_mutable()?;
if self.require_node(node)?.cursor.as_ref() == Some(&cursor) {
return Ok(());
}
self.nodes
.get_mut(&node)
.map(Arc::make_mut)
.expect("node checked above")
.cursor = Some(cursor.clone());
self.journal.push_coalesced(
DirtySlot::Cursor(node),
Operation::SetCursor { node, cursor },
);
Ok(())
}
pub fn set_pointer_capture(
&mut self,
node: NodeId,
pointer: PointerId,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
self.require_node(node)?;
if self.pointer_captures.get(&pointer) == Some(&node) {
return Ok(());
}
self.pointer_captures.insert(pointer, node);
self.journal.push_coalesced(
DirtySlot::Pointer(node, pointer),
Operation::SetPointerCapture { node, pointer },
);
Ok(())
}
pub fn release_pointer_capture(
&mut self,
node: NodeId,
pointer: PointerId,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
self.require_node(node)?;
if self.pointer_captures.get(&pointer) != Some(&node) {
return Ok(());
}
self.pointer_captures.remove(&pointer);
self.journal.push_coalesced(
DirtySlot::Pointer(node, pointer),
Operation::ReleasePointerCapture { node, pointer },
);
Ok(())
}
pub fn invoke_command(
&mut self,
node: NodeId,
command: CommandId,
arguments: WhiskerValue,
) -> Result<(), SceneError> {
self.ensure_mutable()?;
self.require_node(node)?;
self.journal.push_barrier(Operation::InvokeCommand {
node,
command,
arguments,
});
Ok(())
}
pub fn prepare_frame(
&mut self,
viewport_epoch: u32,
) -> Result<Option<&FramePacket>, SceneError> {
if self.pending.is_some() {
return Err(SceneError::FramePending);
}
if !self.needs_snapshot && self.journal.operations.is_empty() {
return Ok(None);
}
let target_revision = self
.accepted_revision
.checked_add(1)
.ok_or(SceneError::RevisionExhausted)?;
let frame_id = self.next_frame_id;
self.next_frame_id = self
.next_frame_id
.checked_add(1)
.ok_or(SceneError::FrameIdExhausted)?;
let mode = if self.needs_snapshot {
FrameMode::Snapshot
} else {
FrameMode::Delta
};
let operations = if mode == FrameMode::Snapshot {
self.snapshot_operations()
} else {
self.journal.operations.clone()
};
self.pending = Some(FramePacket {
header: FrameHeader {
version: self.protocol,
surface: self.surface,
scene_epoch: self.scene_epoch,
frame_id,
base_revision: if mode == FrameMode::Snapshot {
0
} else {
self.accepted_revision
},
target_revision,
viewport_epoch,
mode,
},
operations,
});
Ok(self.pending.as_ref())
}
pub fn accept_pending(&mut self, revision: u64) -> Result<(), SceneError> {
let expected = self
.pending
.as_ref()
.ok_or(SceneError::NoPendingFrame)?
.header
.target_revision;
if revision != expected {
return Err(SceneError::AcceptedRevisionMismatch {
expected,
received: revision,
});
}
self.accepted_revision = revision;
self.pending = None;
self.needs_snapshot = false;
self.journal.clear();
Ok(())
}
pub fn discard_pending(&mut self) -> Result<(), SceneError> {
self.pending.take().ok_or(SceneError::NoPendingFrame)?;
Ok(())
}
pub fn require_snapshot(&mut self) -> Result<(), SceneError> {
self.pending = None;
for node in self.nodes.values_mut() {
Arc::make_mut(node).host_scroll_offset = [0.0; 2];
}
if !self.needs_snapshot {
self.scene_epoch = self
.scene_epoch
.checked_add(1)
.ok_or(SceneError::SceneEpochExhausted)?;
self.needs_snapshot = true;
}
Ok(())
}
fn ensure_mutable(&self) -> Result<(), SceneError> {
if self.pending.is_some() {
Err(SceneError::FramePending)
} else {
Ok(())
}
}
fn require_node(&self, node: NodeId) -> Result<&SceneNode, SceneError> {
self.nodes
.get(&node)
.map(Arc::as_ref)
.ok_or(SceneError::UnknownNode { node })
}
fn require_direct_child(&self, parent: NodeId, child: NodeId) -> Result<(), SceneError> {
self.require_node(parent)?;
let child_state = self.require_node(child)?;
if child_state.parent != Some(parent) {
return Err(SceneError::NotDirectChild { parent, child });
}
Ok(())
}
fn is_descendant(&self, ancestor: NodeId, candidate: NodeId) -> bool {
let mut cursor = Some(candidate);
while let Some(node) = cursor {
if node == ancestor {
return true;
}
cursor = self.nodes.get(&node).and_then(|entry| entry.parent);
}
false
}
fn snapshot_operations(&self) -> Vec<Operation> {
let mut operations = Vec::new();
let mut nodes: Vec<_> = self.nodes.iter().collect();
nodes.sort_unstable_by_key(|(node, _)| node.get());
for (node, state) in nodes.iter().copied() {
operations.push(Operation::CreateNode {
node: *node,
element_type: state.element_type,
});
}
for (parent, state) in nodes.iter().copied() {
for (index, child) in state.children.iter().enumerate() {
operations.push(Operation::InsertChild {
parent: *parent,
child: *child,
index: index as u32,
});
}
}
for (node, state) in nodes {
if let Some(geometry) = state.layout {
operations.push(Operation::SetLayout {
node: *node,
geometry,
});
}
if let Some(paint) = &state.box_paint {
operations.push(Operation::SetBoxPaint {
node: *node,
paint: paint.clone(),
});
}
if !state.background_layers.is_empty() {
operations.push(Operation::SetBackgroundLayers {
node: *node,
layers: state.background_layers.clone(),
});
}
if state.visual_effects != VisualEffects::default() {
operations.push(Operation::SetVisualEffects {
node: *node,
effects: state.visual_effects.clone(),
});
}
if let Some(clip) = state.clip {
operations.push(Operation::SetClip { node: *node, clip });
}
if let Some(transform) = state.transform {
operations.push(Operation::SetTransform {
node: *node,
transform,
});
}
if let Some(opacity) = state.opacity {
operations.push(Operation::SetOpacity {
node: *node,
opacity,
});
}
if let Some(visibility) = state.visibility {
operations.push(Operation::SetVisibility {
node: *node,
visibility,
});
}
if let Some(z_order) = state.z_order {
operations.push(Operation::SetZOrder {
node: *node,
z_order,
});
}
if let Some(content) = &state.text {
operations.push(Operation::SetText {
node: *node,
content: content.clone(),
});
}
if let Some(style) = &state.text_style {
operations.push(Operation::SetTextStyle {
node: *node,
style: style.clone(),
});
}
if let Some(accessibility) = &state.accessibility {
operations.push(Operation::SetAccessibility {
node: *node,
accessibility: accessibility.clone(),
});
}
for (property, value) in &state.properties {
operations.push(Operation::SetProperty {
node: *node,
property: *property,
value: value.clone(),
});
}
if let Some(event_mask) = state.event_mask {
operations.push(Operation::SetEventMask {
node: *node,
event_mask,
});
}
if let Some(behavior) = state.hit_test {
operations.push(Operation::SetHitTest {
node: *node,
behavior,
});
}
if let Some(cursor) = &state.cursor {
operations.push(Operation::SetCursor {
node: *node,
cursor: cursor.clone(),
});
}
}
for (pointer, node) in &self.pointer_captures {
operations.push(Operation::SetPointerCapture {
node: *node,
pointer: *pointer,
});
}
operations.extend(self.journal.operations.iter().filter_map(|operation| {
let Operation::InvokeCommand { node, .. } = operation else {
return None;
};
self.nodes.contains_key(node).then(|| operation.clone())
}));
operations
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::{FrameSink, RecordingRenderer};
use whisker_protocol::{
ApplyResult, BackgroundAttachment, BackgroundSize, BlendMode, BorderLineStyle, ImageRepeat,
LayoutRect, MeasureFontFamily, MeasureFontStyle, MeasureLineHeight, MeasureTextDirection,
MeasureTextOverflow, MeasureTextWrap, PaintBox, PaintColor, PaintCorners, PaintEdges,
PaintImage, PaintLengthPercentage, PaintPosition, ResourceId, TextContentError,
TextMeasurePayload, TextMeasureStyle, TextStyleSnapshot, ValidationError,
};
fn surface() -> SurfaceId {
SurfaceId::new(1).expect("test surface")
}
fn node(value: u64) -> NodeId {
NodeId::new(value).expect("test node")
}
fn element_type(value: u32) -> ElementTypeId {
ElementTypeId::new(value).expect("test element type")
}
fn property(value: u32) -> PropertyId {
PropertyId::new(value).expect("test property")
}
fn pointer(value: u64) -> PointerId {
PointerId::new(value).expect("test pointer")
}
fn command(value: u32) -> CommandId {
CommandId::new(value).expect("test command")
}
fn text_content(text: &str) -> TextContent {
TextContent {
payload: TextMeasurePayload {
text: text.into(),
style: TextMeasureStyle {
font_families: vec![MeasureFontFamily::System],
font_size: 14.0,
font_weight: 400,
font_style: MeasureFontStyle::Normal,
line_height: MeasureLineHeight::Normal,
letter_spacing: 0.0,
..TextMeasureStyle::default()
},
locale: None,
direction: MeasureTextDirection::Auto,
alignment: whisker_protocol::MeasureTextAlignment::Start,
indent: Default::default(),
wrap: MeasureTextWrap::Wrap,
word_break: Default::default(),
max_lines: None,
overflow: MeasureTextOverflow::Clip,
},
paint: whisker_protocol::TextPaint::default(),
prepared_content: None,
}
}
fn box_paint(color: &str) -> BoxPaint {
let zero = PaintLengthPercentage::default();
BoxPaint {
background_color: PaintColor::Named(color.into()),
border_widths: PaintEdges {
top: zero,
right: zero,
bottom: zero,
left: zero,
},
border_colors: PaintEdges {
top: PaintColor::default(),
right: PaintColor::default(),
bottom: PaintColor::default(),
left: PaintColor::default(),
},
border_styles: PaintEdges {
top: BorderLineStyle::None,
right: BorderLineStyle::None,
bottom: BorderLineStyle::None,
left: BorderLineStyle::None,
},
border_radii: PaintCorners {
top_left: whisker_protocol::PaintCornerRadius::circular(zero),
top_right: whisker_protocol::PaintCornerRadius::circular(zero),
bottom_right: whisker_protocol::PaintCornerRadius::circular(zero),
bottom_left: whisker_protocol::PaintCornerRadius::circular(zero),
},
}
}
fn resource_background(resource: u64) -> BackgroundLayer {
BackgroundLayer {
image: PaintImage::Resource(ResourceId::new(resource).unwrap()),
position: PaintPosition::default(),
size: BackgroundSize::Auto,
repeat_x: ImageRepeat::Repeat,
repeat_y: ImageRepeat::Repeat,
origin: PaintBox::Padding,
clip: PaintBox::Border,
attachment: BackgroundAttachment::Scroll,
blend_mode: BlendMode::Normal,
}
}
fn prepared(scene: &mut Scene) -> FramePacket {
scene
.prepare_frame(7)
.expect("prepare frame")
.expect("scene has work")
.clone()
}
fn present_and_accept(scene: &mut Scene, renderer: &mut RecordingRenderer) -> FramePacket {
let packet = prepared(scene);
let outcome = renderer.present(&packet).expect("valid engine packet");
let revision = packet.header.target_revision;
assert_eq!(outcome, ApplyResult::Accepted { revision });
scene.accept_pending(revision).expect("matching acceptance");
packet
}
fn initialized_scene() -> (Scene, RecordingRenderer, NodeId, NodeId) {
let mut scene = Scene::new(surface());
let root = scene.create_node(element_type(1)).expect("create root");
let child = scene.create_node(element_type(2)).expect("create child");
scene.insert_child(root, child, 0).expect("attach child");
let mut renderer = RecordingRenderer::new(surface());
present_and_accept(&mut scene, &mut renderer);
(scene, renderer, root, child)
}
#[test]
fn initial_snapshot_rebuilds_complete_retained_state() {
let mut scene = Scene::new(surface());
assert_eq!(scene.surface(), surface());
assert_eq!(scene.scene_epoch(), 1);
assert_eq!(scene.accepted_revision(), 0);
assert!(scene.has_pending_work());
let root = scene.create_node(element_type(1)).expect("create root");
let child = scene.create_node(element_type(2)).expect("create child");
scene.insert_child(root, child, 0).expect("attach child");
let rect = LayoutRect {
x: 1.0,
y: 2.0,
width: 300.0,
height: 200.0,
};
scene.set_layout(root, rect).expect("layout");
let paint = box_paint("navy");
scene.set_box_paint(root, paint.clone()).expect("box paint");
let background = resource_background(9);
scene
.set_background_layers(root, vec![background.clone()])
.expect("background layers");
let effects = VisualEffects {
backdrop_blur: Some(12.0),
..VisualEffects::default()
};
scene
.set_visual_effects(root, effects.clone())
.expect("visual effects");
let clip = BoxClip {
horizontal: OverflowClip::Hidden,
vertical: OverflowClip::Visible,
};
scene.set_clip(root, clip).expect("clip");
scene
.set_transform(root, Transform::IDENTITY)
.expect("transform");
scene.set_opacity(root, 0.75).expect("opacity");
scene
.set_visibility(root, Visibility::Visible)
.expect("visibility");
scene.set_z_order(root, -1).expect("z order");
let text = text_content("hello");
scene.set_text(root, text.clone()).expect("text");
let text_style = TextStyleSnapshot::from(&text);
scene
.set_text_style(root, text_style.clone())
.expect("text style");
let accessibility = Accessibility::new()
.label("Greeting")
.role(whisker_protocol::AccessibilityRole::Header);
scene
.set_accessibility(root, accessibility.clone())
.expect("accessibility");
scene
.set_property(root, property(1), WhiskerValue::String("red".into()))
.expect("property");
scene.set_event_mask(root, 3).expect("event mask");
scene
.set_hit_test(root, HitTestBehavior::BoxOnly)
.expect("hit test");
let cursor = whisker_protocol::Cursor {
resources: Vec::new(),
fallback: whisker_protocol::CursorKeyword::Grab,
};
scene.set_cursor(root, cursor.clone()).expect("cursor");
scene
.set_pointer_capture(root, pointer(1))
.expect("pointer capture");
scene
.invoke_command(root, command(1), WhiskerValue::Array(Vec::new()))
.expect("command");
let root_state = scene.node(root).expect("root state");
assert_eq!(root_state.element_type(), element_type(1));
assert_eq!(root_state.parent(), None);
assert_eq!(root_state.children(), &[child]);
assert_eq!(root_state.layout(), Some(rect.into()));
assert_eq!(root_state.text(), Some(&text));
assert_eq!(root_state.text_style(), Some(&text_style));
assert_eq!(root_state.accessibility(), Some(&accessibility));
assert_eq!(root_state.box_paint(), Some(&paint));
assert_eq!(root_state.visual_effects(), &effects);
assert_eq!(root_state.clip(), Some(clip));
assert_eq!(root_state.transform(), Some(Transform::IDENTITY));
assert_eq!(root_state.opacity(), Some(0.75));
assert_eq!(root_state.visibility(), Some(Visibility::Visible));
assert_eq!(root_state.z_order(), Some(-1));
assert_eq!(root_state.event_mask(), Some(3));
assert_eq!(root_state.hit_test(), Some(HitTestBehavior::BoxOnly));
assert_eq!(root_state.cursor(), Some(&cursor));
assert_eq!(scene.node(child).expect("child state").parent(), Some(root));
assert_eq!(scene.node_count(), 2);
let mut renderer = RecordingRenderer::new(surface());
let packet = present_and_accept(&mut scene, &mut renderer);
assert_eq!(packet.header.mode, FrameMode::Snapshot);
assert_eq!(packet.header.base_revision, 0);
assert_eq!(packet.header.target_revision, 1);
assert_eq!(packet.header.viewport_epoch, 7);
assert_eq!(renderer.projection().node_count(), 2);
assert_eq!(scene.accepted_revision(), 1);
assert!(packet.operations.iter().any(|operation| {
matches!(
operation,
Operation::SetBackgroundLayers { node, layers }
if *node == root && layers == std::slice::from_ref(&background)
)
}));
assert!(packet.operations.iter().any(|operation| {
matches!(
operation,
Operation::SetCursor { node, cursor: actual }
if *node == root && actual == &cursor
)
}));
assert!(packet.operations.iter().any(|operation| {
matches!(
operation,
Operation::SetVisualEffects { node, effects: actual }
if *node == root && actual == &effects
)
}));
assert!(packet.operations.iter().any(|operation| {
matches!(
operation,
Operation::SetTextStyle { node, style }
if *node == root && style == &text_style
)
}));
assert!(packet.operations.iter().any(|operation| {
matches!(
operation,
Operation::SetAccessibility { node, accessibility: actual }
if *node == root && actual == &accessibility
)
}));
assert!(!scene.has_pending_work());
assert_eq!(scene.prepare_frame(8).expect("idle frame"), None);
}
#[test]
fn equal_values_are_idle_and_delta_values_coalesce_between_barriers() {
let (mut scene, mut renderer, root, _) = initialized_scene();
let first = LayoutRect {
width: 10.0,
height: 20.0,
..LayoutRect::default()
};
let second = LayoutRect {
width: 30.0,
height: 40.0,
..LayoutRect::default()
};
scene.set_layout(root, first).expect("first layout");
scene.set_layout(root, second).expect("second layout");
scene.set_layout(root, second).expect("equal layout");
let first_paint = box_paint("red");
let second_paint = box_paint("blue");
scene
.set_box_paint(root, first_paint)
.expect("first box paint");
scene
.set_box_paint(root, second_paint.clone())
.expect("coalesced box paint");
scene
.set_box_paint(root, second_paint)
.expect("equal box paint");
scene
.set_background_layers(root, vec![resource_background(1)])
.expect("first background");
scene
.set_background_layers(root, vec![resource_background(2)])
.expect("coalesced background");
scene
.set_background_layers(root, vec![resource_background(2)])
.expect("equal background");
let effects = VisualEffects {
backdrop_blur: Some(8.0),
..VisualEffects::default()
};
scene
.set_visual_effects(root, effects.clone())
.expect("visual effects");
scene
.set_visual_effects(root, effects)
.expect("equal visual effects");
let clip = BoxClip {
horizontal: OverflowClip::Visible,
vertical: OverflowClip::Hidden,
};
scene.set_clip(root, clip).expect("clip");
scene.set_clip(root, clip).expect("equal clip");
scene
.set_transform(root, Transform::IDENTITY)
.expect("transform");
scene
.set_transform(root, Transform::IDENTITY)
.expect("equal transform");
scene.set_opacity(root, 0.2).expect("first opacity");
scene.set_opacity(root, 0.4).expect("coalesced opacity");
scene.set_opacity(root, 0.4).expect("equal opacity");
scene
.set_visibility(root, Visibility::Hidden)
.expect("visibility");
scene
.set_visibility(root, Visibility::Hidden)
.expect("equal visibility");
scene.set_z_order(root, 4).expect("z order");
scene.set_z_order(root, 4).expect("equal z order");
let text = text_content("updated");
scene.set_text(root, text.clone()).expect("text");
scene.set_text(root, text).expect("equal text");
let mut first_text_style = TextStyleSnapshot::from(&text_content("first style"));
let mut second_text_style = first_text_style.clone();
first_text_style.paint.foreground = PaintColor::Named("red".into());
second_text_style.paint.foreground = PaintColor::Named("blue".into());
scene
.set_text_style(root, first_text_style)
.expect("first text style");
scene
.set_text_style(root, second_text_style.clone())
.expect("coalesced text style");
scene
.set_text_style(root, second_text_style)
.expect("equal text style");
let accessibility = Accessibility::new().label("Updated");
scene
.set_accessibility(root, accessibility.clone())
.expect("accessibility");
scene
.set_accessibility(root, accessibility)
.expect("equal accessibility");
scene
.set_property(root, property(1), WhiskerValue::Int(1))
.expect("first property");
scene
.set_property(root, property(1), WhiskerValue::Int(2))
.expect("coalesced property");
scene
.set_property(root, property(1), WhiskerValue::Int(2))
.expect("equal property");
scene.set_event_mask(root, 7).expect("event mask");
scene.set_event_mask(root, 7).expect("equal event mask");
scene
.set_hit_test(root, HitTestBehavior::DescendantsOnly)
.expect("hit test");
scene
.set_hit_test(root, HitTestBehavior::DescendantsOnly)
.expect("equal hit test");
scene
.set_pointer_capture(root, pointer(1))
.expect("capture");
scene
.set_pointer_capture(root, pointer(1))
.expect("equal capture");
scene
.invoke_command(root, command(1), WhiskerValue::Null)
.expect("barrier command");
scene.set_opacity(root, 0.8).expect("post-barrier opacity");
let packet = present_and_accept(&mut scene, &mut renderer);
assert_eq!(packet.header.mode, FrameMode::Delta);
assert_eq!(packet.header.base_revision, 1);
assert_eq!(packet.header.target_revision, 2);
assert_eq!(
packet
.operations
.iter()
.filter(|operation| matches!(operation, Operation::SetLayout { .. }))
.count(),
1
);
assert_eq!(
packet
.operations
.iter()
.filter(|operation| matches!(operation, Operation::SetOpacity { .. }))
.count(),
2
);
assert!(!scene.has_pending_work());
}
#[test]
fn clear_and_pointer_release_coalesce_and_skip_absent_values() {
let (mut scene, mut renderer, root, _) = initialized_scene();
let property = property(1);
let pointer = pointer(1);
scene.clear_property(root, property).expect("absent clear");
scene
.release_pointer_capture(root, pointer)
.expect("absent release");
assert!(!scene.has_pending_work());
scene
.set_property(root, property, WhiskerValue::Bool(true))
.expect("set property");
scene
.clear_property(root, property)
.expect("clear property");
scene
.set_pointer_capture(root, pointer)
.expect("capture pointer");
scene
.release_pointer_capture(root, pointer)
.expect("release pointer");
let packet = present_and_accept(&mut scene, &mut renderer);
assert_eq!(
packet.operations,
vec![
Operation::ClearProperty {
node: root,
property,
},
Operation::ReleasePointerCapture {
node: root,
pointer,
},
]
);
}
#[test]
fn structural_delta_supports_move_remove_reinsert_and_subtree_delete() {
let (mut scene, mut renderer, root, child) = initialized_scene();
let sibling = scene.create_node(element_type(3)).expect("sibling");
let grandchild = scene.create_node(element_type(4)).expect("grandchild");
scene
.insert_child(root, sibling, 1)
.expect("insert sibling");
scene.move_child(root, sibling, 0).expect("move sibling");
scene.remove_child(root, child).expect("remove child");
scene.insert_child(root, child, 1).expect("reinsert child");
scene
.insert_child(child, grandchild, 0)
.expect("insert grandchild");
let removed_pointer = pointer(41);
let retained_pointer = pointer(42);
scene
.set_pointer_capture(grandchild, removed_pointer)
.expect("capture removed descendant");
scene
.set_pointer_capture(sibling, retained_pointer)
.expect("capture retained sibling");
scene.delete_node(child).expect("delete attached subtree");
assert_eq!(scene.node_count(), 2);
assert_eq!(scene.node(root).expect("root").children(), &[sibling]);
assert!(scene.node(child).is_none());
assert!(scene.node(grandchild).is_none());
assert_eq!(scene.pointer_capture_target(removed_pointer), None);
assert_eq!(
scene.pointer_capture_target(retained_pointer),
Some(sibling)
);
present_and_accept(&mut scene, &mut renderer);
scene.delete_node(root).expect("delete unattached root");
present_and_accept(&mut scene, &mut renderer);
assert_eq!(scene.node_count(), 0);
assert_eq!(renderer.projection().node_count(), 0);
}
#[test]
fn pending_frame_requires_explicit_accept_or_discard() {
let (mut scene, _, root, _) = initialized_scene();
scene.set_opacity(root, 0.5).expect("dirty scene");
let first = prepared(&mut scene);
assert!(scene.has_pending_work());
assert_eq!(scene.prepare_frame(7), Err(SceneError::FramePending));
assert_eq!(scene.set_opacity(root, 0.7), Err(SceneError::FramePending));
assert_eq!(
scene.set_text(root, text_content("pending")),
Err(SceneError::FramePending)
);
assert_eq!(
scene.set_text_style(
root,
TextStyleSnapshot::from(&text_content("pending style"))
),
Err(SceneError::FramePending)
);
assert_eq!(
scene.set_accessibility(root, Accessibility::new()),
Err(SceneError::FramePending)
);
assert_eq!(
scene.create_node(element_type(3)),
Err(SceneError::FramePending)
);
assert_eq!(scene.delete_node(root), Err(SceneError::FramePending));
assert_eq!(
scene.insert_child(root, root, 0),
Err(SceneError::FramePending)
);
assert_eq!(
scene.remove_child(root, root),
Err(SceneError::FramePending)
);
assert_eq!(
scene.move_child(root, root, 0),
Err(SceneError::FramePending)
);
assert_eq!(
scene.set_layout(root, LayoutRect::default()),
Err(SceneError::FramePending)
);
assert_eq!(
scene.set_visual_effects(root, VisualEffects::default()),
Err(SceneError::FramePending)
);
assert_eq!(
scene.set_transform(root, Transform::IDENTITY),
Err(SceneError::FramePending)
);
assert_eq!(
scene.set_visibility(root, Visibility::Visible),
Err(SceneError::FramePending)
);
assert_eq!(scene.set_z_order(root, 0), Err(SceneError::FramePending));
assert_eq!(
scene.set_property(root, property(1), WhiskerValue::Null),
Err(SceneError::FramePending)
);
assert_eq!(
scene.clear_property(root, property(1)),
Err(SceneError::FramePending)
);
assert_eq!(scene.set_event_mask(root, 0), Err(SceneError::FramePending));
assert_eq!(
scene.set_hit_test(root, HitTestBehavior::Auto),
Err(SceneError::FramePending)
);
assert_eq!(
scene.set_pointer_capture(root, pointer(1)),
Err(SceneError::FramePending)
);
assert_eq!(
scene.release_pointer_capture(root, pointer(1)),
Err(SceneError::FramePending)
);
assert_eq!(
scene.invoke_command(root, command(1), WhiskerValue::Null),
Err(SceneError::FramePending)
);
assert_eq!(
scene.accept_pending(first.header.target_revision + 1),
Err(SceneError::AcceptedRevisionMismatch {
expected: first.header.target_revision,
received: first.header.target_revision + 1,
})
);
scene.discard_pending().expect("discard retry");
assert_eq!(scene.discard_pending(), Err(SceneError::NoPendingFrame));
let retry = prepared(&mut scene);
assert_ne!(first.header.frame_id, retry.header.frame_id);
assert_eq!(first.operations, retry.operations);
scene
.accept_pending(retry.header.target_revision)
.expect("accept retry");
assert_eq!(scene.accept_pending(3), Err(SceneError::NoPendingFrame));
}
#[test]
fn configured_protocol_version_is_written_to_every_frame() {
let protocol = ProtocolVersion { major: 1, minor: 2 };
let mut scene = Scene::with_protocol(surface(), protocol);
let packet = scene.prepare_frame(1).unwrap().unwrap();
assert_eq!(packet.header.version, protocol);
}
#[test]
fn snapshots_create_nodes_in_allocation_order() {
let mut scene = Scene::new(surface());
let expected: Vec<_> = (0..64)
.map(|_| scene.create_node(element_type(1)).expect("node"))
.collect();
scene.set_opacity(expected[0], 0.5).expect("opacity");
let snapshot = prepared(&mut scene);
let actual: Vec<_> = snapshot
.operations
.iter()
.filter_map(|operation| match operation {
Operation::CreateNode { node, .. } => Some(*node),
_ => None,
})
.collect();
assert_eq!(actual, expected);
}
#[test]
fn need_snapshot_rotates_epoch_and_rebuilds_current_state() {
let (mut scene, _, root, child) = initialized_scene();
scene
.update_host_scroll_offset(root, [0.0, 42.0])
.expect("Host scroll state");
scene.set_opacity(root, 0.5).expect("delta");
let delta = prepared(&mut scene);
let mut empty_renderer = RecordingRenderer::new(surface());
assert_eq!(
empty_renderer.present(&delta),
Ok(ApplyResult::NeedSnapshot {
receiver_revision: 0
})
);
scene.require_snapshot().expect("recovery snapshot");
assert_eq!(scene.node(root).unwrap().host_scroll_offset(), [0.0; 2]);
assert_eq!(scene.scene_epoch(), 2);
scene.require_snapshot().expect("already snapshot mode");
assert_eq!(scene.scene_epoch(), 2);
let snapshot = prepared(&mut scene);
assert_eq!(snapshot.header.mode, FrameMode::Snapshot);
assert_eq!(snapshot.header.scene_epoch, 2);
assert!(snapshot.operations.iter().any(
|operation| matches!(operation, Operation::InsertChild { parent, child: value, .. } if *parent == root && *value == child)
));
let outcome = empty_renderer
.present(&snapshot)
.expect("recovery snapshot accepted");
let revision = snapshot.header.target_revision;
assert_eq!(outcome, ApplyResult::Accepted { revision });
scene.accept_pending(revision).expect("accept snapshot");
assert_eq!(empty_renderer.projection().node_count(), 2);
}
#[test]
fn deleted_command_target_is_omitted_from_initial_snapshot() {
let mut scene = Scene::new(surface());
let doomed = scene.create_node(element_type(1)).expect("doomed node");
scene
.invoke_command(doomed, command(1), WhiskerValue::Null)
.expect("queued command");
scene.delete_node(doomed).expect("delete command target");
let snapshot = prepared(&mut scene);
assert!(snapshot.operations.is_empty());
}
#[test]
fn mutation_validation_preserves_the_retained_tree() {
let (mut scene, _, root, child) = initialized_scene();
let missing = node(99);
let unattached = scene.create_node(element_type(3)).expect("unattached");
assert_eq!(
scene.insert_child(missing, unattached, 0),
Err(SceneError::UnknownNode { node: missing })
);
assert_eq!(
scene.insert_child(root, missing, 0),
Err(SceneError::UnknownNode { node: missing })
);
assert_eq!(
scene.insert_child(root, child, 0),
Err(SceneError::ChildAlreadyAttached {
child,
parent: root,
})
);
assert_eq!(
scene.insert_child(root, unattached, 2),
Err(SceneError::ChildIndexOutOfBounds {
parent: root,
index: 2,
len: 1,
})
);
assert_eq!(
scene.insert_child(unattached, unattached, 0),
Err(SceneError::TreeCycle {
parent: unattached,
child: unattached,
})
);
assert_eq!(
scene.insert_child(child, root, 0),
Err(SceneError::TreeCycle {
parent: child,
child: root,
})
);
assert_eq!(
scene.remove_child(root, unattached),
Err(SceneError::NotDirectChild {
parent: root,
child: unattached,
})
);
assert_eq!(
scene.move_child(root, unattached, 0),
Err(SceneError::NotDirectChild {
parent: root,
child: unattached,
})
);
assert_eq!(
scene.move_child(root, child, 1),
Err(SceneError::ChildIndexOutOfBounds {
parent: root,
index: 1,
len: 0,
})
);
assert_eq!(scene.node(root).expect("root").children(), &[child]);
}
#[test]
fn unknown_nodes_are_rejected_by_every_mutation_family() {
let (mut scene, _, _, _) = initialized_scene();
let missing = node(99);
let operations = [
scene.delete_node(missing),
scene.set_layout(missing, LayoutRect::default()),
scene.set_box_paint(missing, box_paint("missing")),
scene.set_visual_effects(missing, VisualEffects::default()),
scene.set_clip(
missing,
BoxClip {
horizontal: OverflowClip::Visible,
vertical: OverflowClip::Visible,
},
),
scene.set_transform(missing, Transform::IDENTITY),
scene.set_opacity(missing, 1.0),
scene.set_visibility(missing, Visibility::Visible),
scene.set_z_order(missing, 0),
scene.set_text(missing, text_content("missing")),
scene.set_text_style(
missing,
TextStyleSnapshot::from(&text_content("missing style")),
),
scene.set_accessibility(missing, Accessibility::new()),
scene.set_property(missing, property(1), WhiskerValue::Null),
scene.clear_property(missing, property(1)),
scene.set_event_mask(missing, 0),
scene.set_hit_test(missing, HitTestBehavior::Auto),
scene.set_pointer_capture(missing, pointer(1)),
scene.release_pointer_capture(missing, pointer(1)),
scene.invoke_command(missing, command(1), WhiskerValue::Null),
scene.remove_child(missing, node(1)),
scene.remove_child(node(1), missing),
];
for outcome in operations {
assert_eq!(outcome, Err(SceneError::UnknownNode { node: missing }));
}
}
#[test]
fn numeric_and_result_validation_reject_invalid_values() {
let (mut scene, _, root, _) = initialized_scene();
let invalid_layout = LayoutRect {
width: f32::NAN,
..LayoutRect::default()
};
assert_eq!(
scene.set_layout(root, invalid_layout),
Err(SceneError::NonFiniteNumber)
);
let mut invalid_paint = box_paint("invalid");
invalid_paint.border_widths.top.length = -1.0;
assert_eq!(
scene.set_box_paint(root, invalid_paint),
Err(SceneError::InvalidBoxPaint)
);
let invalid_effects = VisualEffects {
backdrop_blur: Some(-1.0),
..VisualEffects::default()
};
assert_eq!(
scene.set_visual_effects(root, invalid_effects),
Err(SceneError::InvalidVisualEffects)
);
let mut invalid_text = text_content("invalid");
invalid_text.payload.style.font_families.clear();
assert_eq!(
scene.set_text(root, invalid_text),
Err(SceneError::InvalidText {
error: TextContentError::InvalidMeasurement(
whisker_protocol::MeasurementPayloadError::InvalidFontFamily,
),
})
);
let mut invalid_text_style = TextStyleSnapshot::from(&text_content("invalid style"));
invalid_text_style.style.font_families.clear();
assert_eq!(
scene.set_text_style(root, invalid_text_style),
Err(SceneError::InvalidText {
error: TextContentError::InvalidMeasurement(
whisker_protocol::MeasurementPayloadError::InvalidFontFamily,
),
})
);
let mut invalid_transform = Transform::IDENTITY;
invalid_transform.0[0] = f32::INFINITY;
assert_eq!(
scene.set_transform(root, invalid_transform),
Err(SceneError::NonFiniteNumber)
);
assert_eq!(
scene.set_opacity(root, -0.1),
Err(SceneError::InvalidOpacity { opacity: -0.1 })
);
let nan_error = scene.set_opacity(root, f32::NAN).expect_err("NaN opacity");
assert_eq!(format!("{nan_error:?}"), "InvalidOpacity { opacity: NaN }");
assert!(
SceneError::NonFiniteNumber
.to_string()
.starts_with("Whisker scene error:")
);
let as_error: &dyn Error = &SceneError::NonFiniteNumber;
assert!(as_error.source().is_none());
}
#[test]
fn allocation_and_frame_counters_report_exhaustion() {
let mut scene = Scene::new(surface());
scene.next_node_id = 0;
assert_eq!(
scene.create_node(element_type(1)),
Err(SceneError::NodeIdExhausted)
);
let mut scene = Scene::new(surface());
scene.accepted_revision = u64::MAX;
assert_eq!(scene.prepare_frame(1), Err(SceneError::RevisionExhausted));
let mut scene = Scene::new(surface());
scene.next_frame_id = u64::MAX;
assert_eq!(scene.prepare_frame(1), Err(SceneError::FrameIdExhausted));
let (mut scene, _, _, _) = initialized_scene();
scene.scene_epoch = u32::MAX;
assert_eq!(
scene.require_snapshot(),
Err(SceneError::SceneEpochExhausted)
);
}
#[test]
fn recording_renderer_surfaces_protocol_validation_failures() {
let mut scene = Scene::new(surface());
let packet = prepared(&mut scene);
let mut wrong_renderer =
RecordingRenderer::new(SurfaceId::new(2).expect("different recording surface"));
assert_eq!(
wrong_renderer.present(&packet),
Err(ValidationError::SurfaceMismatch {
expected: SurfaceId::new(2).expect("different recording surface"),
received: surface(),
})
);
}
#[test]
fn hit_testing_respects_z_order_visibility_clip_and_pointer_capture() {
let mut scene = Scene::new(surface());
let root = scene.create_node(element_type(1)).unwrap();
let back = scene.create_node(element_type(1)).unwrap();
let front = scene.create_node(element_type(1)).unwrap();
scene.insert_child(root, back, 0).unwrap();
scene.insert_child(root, front, 1).unwrap();
assert_eq!(
scene.hit_test(root, InputPoint { x: 0.0, y: 0.0 }),
Ok(None)
);
scene
.set_layout(
root,
LayoutRect {
x: 0.0,
y: 0.0,
width: 100.0,
height: 100.0,
},
)
.unwrap();
for child in [back, front] {
scene
.set_layout(
child,
LayoutRect {
x: 0.0,
y: 0.0,
width: 50.0,
height: 50.0,
},
)
.unwrap();
}
scene.set_z_order(back, 1).unwrap();
scene.set_z_order(front, 2).unwrap();
let point = InputPoint { x: 10.0, y: 10.0 };
assert_eq!(scene.hit_test(root, point), Ok(Some(front)));
scene.set_z_order(back, 3).unwrap();
assert_eq!(scene.hit_test(root, point), Ok(Some(back)));
scene.set_z_order(back, 1).unwrap();
scene.set_hit_test(root, HitTestBehavior::BoxOnly).unwrap();
assert_eq!(scene.hit_test(root, point), Ok(Some(root)));
scene.set_hit_test(root, HitTestBehavior::Auto).unwrap();
scene.set_visibility(front, Visibility::Hidden).unwrap();
assert_eq!(scene.hit_test(root, point), Ok(Some(back)));
scene.set_hit_test(front, HitTestBehavior::None).unwrap();
scene.set_visibility(front, Visibility::Visible).unwrap();
assert_eq!(scene.hit_test(root, point), Ok(Some(back)));
scene
.set_hit_test(back, HitTestBehavior::DescendantsOnly)
.unwrap();
assert_eq!(scene.hit_test(root, point), Ok(Some(root)));
scene
.set_layout(
back,
LayoutRect {
x: 120.0,
y: 0.0,
width: 50.0,
height: 50.0,
},
)
.unwrap();
scene.set_hit_test(back, HitTestBehavior::Auto).unwrap();
scene
.set_clip(
root,
BoxClip {
horizontal: OverflowClip::Hidden,
vertical: OverflowClip::Visible,
},
)
.unwrap();
let outside = InputPoint { x: 130.0, y: 10.0 };
assert_eq!(scene.hit_test(root, outside), Ok(None));
scene
.set_clip(
root,
BoxClip {
horizontal: OverflowClip::Visible,
vertical: OverflowClip::Visible,
},
)
.unwrap();
assert_eq!(scene.hit_test(root, outside), Ok(Some(back)));
scene
.set_layout(
back,
LayoutRect {
x: 0.0,
y: 120.0,
width: 50.0,
height: 50.0,
},
)
.unwrap();
scene
.set_clip(
root,
BoxClip {
horizontal: OverflowClip::Visible,
vertical: OverflowClip::Hidden,
},
)
.unwrap();
assert_eq!(
scene.hit_test(root, InputPoint { x: 10.0, y: 130.0 }),
Ok(None)
);
let pointer = pointer(9);
scene.set_pointer_capture(back, pointer).unwrap();
assert_eq!(scene.pointer_capture_target(pointer), Some(back));
scene.release_pointer_capture(back, pointer).unwrap();
assert_eq!(scene.pointer_capture_target(pointer), None);
assert_eq!(
scene.hit_test(node(999), point),
Err(SceneError::UnknownNode { node: node(999) })
);
}
}