use std::{collections::HashMap, error::Error, fmt, rc::Rc};
use whisker_layout::{IntrinsicMeasurer, LayoutError, LayoutSize, LayoutSnapshot, LayoutTree};
use whisker_protocol::{
Accessibility, ApplyResult, BackgroundLayer, BoxPaint, CommandId, Cursor, CursorKeyword,
ElementTypeId, FramePacket, HitTestBehavior, InputPoint, LayoutGeometry, MeasurementMetrics,
MeasurementReady, MeasurementResponse, MeasurementSpec, NodeId, PointerId, PropertyId,
SurfaceId, TextContent, WhiskerValue,
};
use whisker_style::{
ComputedLayoutStyle, ComputedStyle, ComputedTransformStyle, CursorValue, PointerEventsValue,
PropertyImpactSet,
};
#[cfg(test)]
use crate::radial_gradient::absolute_length;
use crate::radial_gradient::{
RadialBackgroundSource, canonicalize as canonicalize_radial_backgrounds,
sources as radial_background_sources,
};
use crate::{
DeferredMeasurementApply, FrameSink, LayoutProgress, MeasurementApply, MeasurementError,
PlainTextInput, Scene, SceneError, SceneNode, lower_paint, lower_plain_text, lower_text_style,
lower_transform, measurement::MeasurementCoordinator,
};
const fn lower_hit_test(value: PointerEventsValue) -> HitTestBehavior {
match value {
PointerEventsValue::Auto => HitTestBehavior::Auto,
PointerEventsValue::None => HitTestBehavior::None,
}
}
fn lower_cursor(value: CursorValue) -> Cursor {
let fallback = match value {
CursorValue::Auto => CursorKeyword::Auto,
CursorValue::Default => CursorKeyword::Default,
CursorValue::None => CursorKeyword::None,
CursorValue::ContextMenu => CursorKeyword::ContextMenu,
CursorValue::Help => CursorKeyword::Help,
CursorValue::Pointer => CursorKeyword::Pointer,
CursorValue::Progress => CursorKeyword::Progress,
CursorValue::Wait => CursorKeyword::Wait,
CursorValue::Cell => CursorKeyword::Cell,
CursorValue::Crosshair => CursorKeyword::Crosshair,
CursorValue::Text => CursorKeyword::Text,
CursorValue::VerticalText => CursorKeyword::VerticalText,
CursorValue::Alias => CursorKeyword::Alias,
CursorValue::Copy => CursorKeyword::Copy,
CursorValue::Move => CursorKeyword::Move,
CursorValue::NoDrop => CursorKeyword::NoDrop,
CursorValue::NotAllowed => CursorKeyword::NotAllowed,
CursorValue::Grab => CursorKeyword::Grab,
CursorValue::Grabbing => CursorKeyword::Grabbing,
CursorValue::ColResize => CursorKeyword::ColResize,
CursorValue::RowResize => CursorKeyword::RowResize,
CursorValue::NResize => CursorKeyword::NResize,
CursorValue::EResize => CursorKeyword::EResize,
CursorValue::SResize => CursorKeyword::SResize,
CursorValue::WResize => CursorKeyword::WResize,
CursorValue::NeResize => CursorKeyword::NeResize,
CursorValue::NwResize => CursorKeyword::NwResize,
CursorValue::SeResize => CursorKeyword::SeResize,
CursorValue::SwResize => CursorKeyword::SwResize,
CursorValue::EwResize => CursorKeyword::EwResize,
CursorValue::NsResize => CursorKeyword::NsResize,
CursorValue::NeswResize => CursorKeyword::NeswResize,
CursorValue::NwseResize => CursorKeyword::NwseResize,
CursorValue::ZoomIn => CursorKeyword::ZoomIn,
CursorValue::ZoomOut => CursorKeyword::ZoomOut,
};
Cursor {
resources: Vec::new(),
fallback,
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct LayoutUpdate {
recomputed: bool,
changed_nodes: usize,
}
impl LayoutUpdate {
fn computed(changed_nodes: usize) -> Self {
Self {
recomputed: true,
changed_nodes,
}
}
pub const fn recomputed(self) -> bool {
self.recomputed
}
pub const fn changed_nodes(self) -> usize {
self.changed_nodes
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum SurfaceError {
Scene(SceneError),
Layout(LayoutError),
SceneLayoutMismatch {
node: NodeId,
},
InvalidLayoutOutput {
node: NodeId,
},
InvalidTransformOutput {
node: NodeId,
},
Measurement(MeasurementError),
}
impl fmt::Display for SurfaceError {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "Whisker surface error: {self:?}")
}
}
impl Error for SurfaceError {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Scene(error) => Some(error),
Self::Layout(error) => Some(error),
Self::Measurement(error) => Some(error),
Self::SceneLayoutMismatch { .. }
| Self::InvalidLayoutOutput { .. }
| Self::InvalidTransformOutput { .. } => None,
}
}
}
impl From<SceneError> for SurfaceError {
fn from(error: SceneError) -> Self {
Self::Scene(error)
}
}
impl From<LayoutError> for SurfaceError {
fn from(error: LayoutError) -> Self {
Self::Layout(error)
}
}
impl From<MeasurementError> for SurfaceError {
fn from(error: MeasurementError) -> Self {
Self::Measurement(error)
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum SurfacePresentError<SinkError> {
Surface(SurfaceError),
Sink(SinkError),
}
impl<SinkError: fmt::Debug> fmt::Display for SurfacePresentError<SinkError> {
fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(formatter, "Whisker surface presentation error: {self:?}")
}
}
impl<SinkError: Error + 'static> Error for SurfacePresentError<SinkError> {
fn source(&self) -> Option<&(dyn Error + 'static)> {
match self {
Self::Surface(error) => Some(error),
Self::Sink(error) => Some(error),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
struct LayoutInputs {
root: NodeId,
viewport: LayoutSize,
}
#[derive(Clone, Debug)]
pub struct SurfaceEngine {
scene: Scene,
layout: Rc<LayoutTree>,
last_layout: Option<Rc<LayoutSnapshot>>,
last_inputs: Option<LayoutInputs>,
layout_dirty: bool,
layout_provisional: bool,
transforms: Rc<HashMap<NodeId, ComputedTransformStyle>>,
radial_backgrounds: Rc<HashMap<NodeId, Vec<RadialBackgroundSource>>>,
paragraph_visibility: Rc<crate::paragraph_visibility::ParagraphVisibility>,
measurements: Rc<MeasurementCoordinator>,
}
impl SurfaceEngine {
pub(crate) fn synchronize_prepared_content<P: crate::MeasurementProvider>(
&self,
provider: &mut P,
) {
let (revision, mut retained) = self.measurements.retained_content();
provider.retain_prepared_content(self.surface(), revision, &mut retained);
}
pub fn new(surface: SurfaceId) -> Self {
Self::with_protocol(surface, whisker_protocol::ProtocolVersion::CURRENT)
}
pub fn with_protocol(surface: SurfaceId, protocol: whisker_protocol::ProtocolVersion) -> Self {
Self {
scene: Scene::with_protocol(surface, protocol),
layout: Rc::new(LayoutTree::new()),
last_layout: None,
last_inputs: None,
layout_dirty: false,
layout_provisional: false,
transforms: Rc::new(HashMap::new()),
radial_backgrounds: Rc::new(HashMap::new()),
paragraph_visibility: Rc::default(),
measurements: Rc::new(MeasurementCoordinator::default()),
}
}
pub const fn surface(&self) -> SurfaceId {
self.scene.surface()
}
pub const fn scene(&self) -> &Scene {
&self.scene
}
pub fn layout_tree(&self) -> &LayoutTree {
&self.layout
}
pub fn last_layout(&self) -> Option<&LayoutSnapshot> {
self.last_layout.as_deref()
}
pub const fn needs_layout(&self) -> bool {
self.layout_dirty
}
pub fn has_pending_work(&self) -> bool {
self.scene.has_pending_work()
}
pub fn node(&self, node: NodeId) -> Option<&SceneNode> {
self.scene.node(node)
}
pub fn hit_test(
&self,
root: NodeId,
point: InputPoint,
) -> Result<Option<NodeId>, SurfaceError> {
self.scene
.hit_test(root, point)
.map_err(SurfaceError::Scene)
}
pub fn update_host_scroll_offset(
&mut self,
node: NodeId,
offset: [f32; 2],
) -> Result<(), SurfaceError> {
self.scene
.update_host_scroll_offset(node, offset)
.map_err(SurfaceError::Scene)
}
pub fn pointer_capture_target(&self, pointer: PointerId) -> Option<NodeId> {
self.scene.pointer_capture_target(pointer)
}
pub fn set_event_mask(&mut self, node: NodeId, mask: u64) -> Result<(), SurfaceError> {
self.scene
.set_event_mask(node, mask)
.map_err(SurfaceError::Scene)
}
pub fn set_accessibility(
&mut self,
node: NodeId,
accessibility: Accessibility,
) -> Result<(), SurfaceError> {
let accessibility = if self.paragraph_visibility.contains(node) {
Rc::make_mut(&mut self.paragraph_visibility).accessibility(node, accessibility)
} else {
accessibility
};
self.scene
.set_accessibility(node, accessibility)
.map_err(SurfaceError::Scene)
}
pub fn set_property(
&mut self,
node: NodeId,
property: PropertyId,
value: WhiskerValue,
) -> Result<(), SurfaceError> {
self.scene
.set_property(node, property, value)
.map_err(SurfaceError::Scene)
}
pub fn clear_property(
&mut self,
node: NodeId,
property: PropertyId,
) -> Result<(), SurfaceError> {
self.scene
.clear_property(node, property)
.map_err(SurfaceError::Scene)
}
pub fn invoke_command(
&mut self,
node: NodeId,
command: CommandId,
arguments: WhiskerValue,
) -> Result<(), SurfaceError> {
self.scene
.invoke_command(node, command, arguments)
.map_err(SurfaceError::Scene)
}
pub fn set_hit_test(
&mut self,
node: NodeId,
behavior: HitTestBehavior,
) -> Result<(), SurfaceError> {
self.scene
.set_hit_test(node, behavior)
.map_err(SurfaceError::Scene)
}
pub fn set_cursor(&mut self, node: NodeId, cursor: Cursor) -> Result<(), SurfaceError> {
self.scene
.set_cursor(node, cursor)
.map_err(SurfaceError::Scene)
}
pub fn set_opacity(&mut self, node: NodeId, opacity: f32) -> Result<(), SurfaceError> {
self.scene
.set_opacity(node, opacity)
.map_err(SurfaceError::Scene)
}
pub fn set_box_paint(&mut self, node: NodeId, paint: BoxPaint) -> Result<(), SurfaceError> {
self.scene
.set_box_paint(node, paint)
.map_err(SurfaceError::Scene)
}
pub fn set_text_content(
&mut self,
node: NodeId,
content: TextContent,
) -> Result<(), SurfaceError> {
self.scene
.set_text(node, content)
.map_err(SurfaceError::Scene)
}
pub fn set_text_style(
&mut self,
node: NodeId,
style: &ComputedStyle,
) -> Result<(), SurfaceError> {
self.scene
.set_text_style(node, lower_text_style(style))
.map_err(SurfaceError::Scene)
}
pub fn set_text_style_snapshot(
&mut self,
node: NodeId,
style: whisker_protocol::TextStyleSnapshot,
) -> Result<(), SurfaceError> {
self.scene
.set_text_style(node, style)
.map_err(SurfaceError::Scene)
}
pub fn set_transform(
&mut self,
node: NodeId,
transform: whisker_protocol::Transform,
) -> Result<(), SurfaceError> {
self.scene
.set_transform(node, transform)
.map_err(SurfaceError::Scene)
}
pub fn create_node(
&mut self,
element_type: ElementTypeId,
style: ComputedLayoutStyle,
) -> Result<NodeId, SurfaceError> {
LayoutTree::validate_style(&style)?;
let node = self.scene.create_node(element_type)?;
Rc::make_mut(&mut self.layout)
.create_node(node, style)
.expect("a validated style and fresh scene ID must enter layout");
self.layout_dirty = true;
Ok(node)
}
pub fn delete_node(&mut self, node: NodeId) -> Result<(), SurfaceError> {
let mut removed = Vec::new();
collect_scene_subtree(&self.scene, node, &mut removed)?;
self.scene.delete_node(node)?;
Rc::make_mut(&mut self.layout)
.remove_subtree(node)
.expect("scene and layout trees remain structurally synchronized");
for removed in removed {
Rc::make_mut(&mut self.transforms).remove(&removed);
Rc::make_mut(&mut self.radial_backgrounds).remove(&removed);
Rc::make_mut(&mut self.measurements).remove_node(removed);
if self.paragraph_visibility.contains(removed) {
Rc::make_mut(&mut self.paragraph_visibility).remove(removed);
}
}
self.layout_dirty = true;
Ok(())
}
pub fn insert_child(
&mut self,
parent: NodeId,
child: NodeId,
index: u32,
) -> Result<(), SurfaceError> {
self.scene.insert_child(parent, child, index)?;
Rc::make_mut(&mut self.layout)
.reparent(child, parent, index as usize)
.expect("scene and layout trees remain structurally synchronized");
self.layout_dirty = true;
Ok(())
}
pub fn remove_child(&mut self, parent: NodeId, child: NodeId) -> Result<(), SurfaceError> {
self.scene.remove_child(parent, child)?;
let children = self
.scene
.node(parent)
.expect("validated parent remains live")
.children()
.to_vec();
Rc::make_mut(&mut self.layout)
.set_children(parent, &children)
.expect("scene and layout trees remain structurally synchronized");
self.layout_dirty = true;
Ok(())
}
pub fn move_child(
&mut self,
parent: NodeId,
child: NodeId,
index: u32,
) -> Result<(), SurfaceError> {
self.scene.move_child(parent, child, index)?;
Rc::make_mut(&mut self.layout)
.reparent(child, parent, index as usize)
.expect("scene and layout trees remain structurally synchronized");
self.layout_dirty = true;
Ok(())
}
pub fn update_layout_style(
&mut self,
node: NodeId,
style: ComputedLayoutStyle,
) -> Result<PropertyImpactSet, SurfaceError> {
self.ensure_mutable()?;
if self.layout.style(node) == Some(&style) {
return Ok(PropertyImpactSet::default());
}
let impact = Rc::make_mut(&mut self.layout).update_style(node, style)?;
self.layout_dirty = true;
Ok(impact)
}
pub fn update_computed_style(
&mut self,
node: NodeId,
style: &ComputedStyle,
) -> Result<PropertyImpactSet, SurfaceError> {
self.ensure_mutable()?;
let lowered = lower_paint(style.paint(), style.layout());
let transform_changed = self.transforms.get(&node) != Some(&lowered.transform);
let projected_transform = self
.last_layout
.as_ref()
.and_then(|layout| layout.get(node))
.copied()
.map(|geometry| {
self.resolve_node_transform(
node,
&lowered.transform,
geometry.border_box.width,
geometry.border_box.height,
)
})
.transpose()?;
let paint_changed = {
let current = self
.scene
.node(node)
.ok_or(SceneError::UnknownNode { node })?;
current.box_paint() != Some(&lowered.box_paint)
|| current.visual_effects() != &lowered.visual_effects
|| current.clip() != Some(lowered.clip)
|| current.opacity() != Some(lowered.opacity)
|| current.visibility() != Some(lowered.visibility)
|| current.z_order() != Some(lowered.z_order)
|| transform_changed
};
let input_changed = {
let current = self
.scene
.node(node)
.expect("the retained scene node was validated above");
current.hit_test() != Some(lower_hit_test(style.pointer_events()))
|| current.cursor() != Some(&lower_cursor(style.cursor()))
};
let mut impacts = self.update_layout_style(node, style.layout().clone())?;
self.scene
.set_box_paint(node, lowered.box_paint)
.expect("lowered paint is valid and the scene is mutable");
self.scene
.set_visual_effects(node, lowered.visual_effects)
.expect("lowered visual effects are valid and the scene is mutable");
self.scene
.set_clip(node, lowered.clip)
.expect("the retained scene node was validated above");
self.scene
.set_opacity(node, lowered.opacity)
.expect("computed opacity is valid and the scene node exists");
let visibility = if self.paragraph_visibility.contains(node) {
Rc::make_mut(&mut self.paragraph_visibility).visibility(node, lowered.visibility)
} else {
lowered.visibility
};
self.scene
.set_visibility(node, visibility)
.expect("the retained scene node was validated above");
self.scene
.set_z_order(node, lowered.z_order)
.expect("the retained scene node was validated above");
self.scene
.set_hit_test(node, lower_hit_test(style.pointer_events()))
.expect("the retained scene node was validated above");
self.scene
.set_cursor(node, lower_cursor(style.cursor()))
.expect("the retained scene node was validated above");
if transform_changed {
Rc::make_mut(&mut self.transforms).insert(node, lowered.transform);
}
if let Some(transform) = projected_transform.flatten() {
self.scene
.set_transform(node, transform)
.expect("the transform was validated before retained style mutation");
}
if paint_changed {
impacts |= PropertyImpactSet::PAINT;
}
if input_changed {
impacts |= PropertyImpactSet::INPUT;
}
Ok(impacts)
}
pub fn set_background_layers(
&mut self,
node: NodeId,
mut layers: Vec<BackgroundLayer>,
) -> Result<(), SurfaceError> {
self.ensure_mutable()?;
let sources = radial_background_sources(&layers);
if let Some(geometry) = self
.last_layout
.as_ref()
.and_then(|layout| layout.get(node))
.copied()
{
let paint = self.scene.node(node).and_then(SceneNode::box_paint);
canonicalize_radial_backgrounds(&mut layers, &sources, geometry, paint);
}
self.scene.set_background_layers(node, layers)?;
if sources.is_empty() {
if self.radial_backgrounds.contains_key(&node) {
Rc::make_mut(&mut self.radial_backgrounds).remove(&node);
}
} else if self.radial_backgrounds.get(&node) != Some(&sources) {
Rc::make_mut(&mut self.radial_backgrounds).insert(node, sources);
}
Ok(())
}
pub fn set_measurable(&mut self, node: NodeId, measurable: bool) -> Result<bool, SurfaceError> {
self.ensure_mutable()?;
if self.layout.is_measurable(node) == Some(measurable) {
return Ok(false);
}
let changed = Rc::make_mut(&mut self.layout).set_measurable(node, measurable)?;
self.layout_dirty |= changed;
Ok(changed)
}
pub fn set_measurement(
&mut self,
node: NodeId,
spec: Option<MeasurementSpec>,
) -> Result<bool, SurfaceError> {
self.ensure_mutable()?;
let element_type = self
.scene
.node(node)
.ok_or(SceneError::UnknownNode { node })?
.element_type();
if !self.layout.contains(node) {
return Err(LayoutError::UnknownNode(node).into());
}
let measurable = spec.is_some();
let spec_changed = !self
.measurements
.matches_spec(node, element_type, spec.as_ref())
&& Rc::make_mut(&mut self.measurements).set_spec(node, element_type, spec)?;
let behavior_changed = self
.set_measurable(node, measurable)
.expect("measurement node was validated on a mutable surface");
let changed = spec_changed || behavior_changed;
if changed {
Rc::make_mut(&mut self.layout)
.invalidate_measurement(node)
.expect("configured measurement node remains in synchronized layout");
self.layout_dirty = true;
}
Ok(changed)
}
pub fn set_plain_text(
&mut self,
node: NodeId,
input: &PlainTextInput,
style: &ComputedStyle,
) -> Result<bool, SurfaceError> {
self.set_lowered_text(node, lower_plain_text(input, style))
}
pub fn set_rich_text(
&mut self,
node: NodeId,
input: &PlainTextInput,
style: &ComputedStyle,
runs: &[crate::ResolvedTextRun],
attachments: &[crate::InlineAttachmentInput],
) -> Result<bool, SurfaceError> {
let paragraph = !runs.is_empty() || !attachments.is_empty();
if self.layout.is_paragraph(node) != paragraph {
Rc::make_mut(&mut self.layout).set_paragraph(node, paragraph)?;
}
let changed = self.set_lowered_text(
node,
crate::lower_rich_text(input, style, runs, attachments),
)?;
if !self
.measurements
.inline_attachments_match(node, attachments)
{
Rc::make_mut(&mut self.measurements).set_inline_attachments(node, attachments);
}
Ok(changed)
}
fn set_lowered_text(
&mut self,
node: NodeId,
lowered: crate::LoweredPlainText,
) -> Result<bool, SurfaceError> {
self.ensure_mutable()?;
let previous = self
.scene
.node(node)
.ok_or(SceneError::UnknownNode { node })?
.text()
.cloned();
let (mut content, measurement) = lowered.into_parts();
let measurement_changed = self.set_measurement(node, Some(measurement))?;
if !measurement_changed && let Some(previous) = &previous {
content.prepared_content = previous.prepared_content;
content.paragraph = previous.paragraph.clone();
content.payload = previous.payload.clone();
}
let content_changed = previous.as_ref() != Some(&content);
self.scene
.set_text(node, content)
.expect("validated synchronized text node remains mutable");
Ok(content_changed || measurement_changed)
}
pub fn last_measurement(&self, node: NodeId) -> Option<&MeasurementMetrics> {
self.measurements.last_ready(node)
}
pub fn invalidate_node(
&mut self,
node: NodeId,
impacts: PropertyImpactSet,
) -> Result<bool, SurfaceError> {
self.ensure_mutable()?;
if self.scene.node(node).is_none() {
return Err(SceneError::UnknownNode { node }.into());
}
let intrinsic = impacts.contains(PropertyImpactSet::INTRINSIC_MEASURE);
if intrinsic {
Rc::make_mut(&mut self.layout).invalidate_measurement(node)?;
}
let requires_layout = intrinsic || impacts.contains(PropertyImpactSet::LAYOUT);
self.layout_dirty |= requires_layout;
Ok(requires_layout)
}
pub fn compute_layout(
&mut self,
root: NodeId,
viewport: LayoutSize,
measurer: &mut dyn IntrinsicMeasurer,
) -> Result<LayoutUpdate, SurfaceError> {
self.ensure_mutable()?;
let inputs = LayoutInputs { root, viewport };
if !self.layout_dirty && self.last_inputs == Some(inputs) {
return Ok(LayoutUpdate::default());
}
let snapshot = Rc::make_mut(&mut self.layout).compute(root, viewport, measurer)?;
let update = self.project_layout(snapshot, inputs)?;
self.layout_provisional = false;
Ok(update)
}
pub fn compute_layout_with_measurements(
&mut self,
root: NodeId,
viewport: LayoutSize,
environment_epoch: u64,
) -> Result<LayoutProgress, SurfaceError> {
self.compute_layout_using(root, viewport, environment_epoch, None)
}
pub(crate) fn compute_layout_using(
&mut self,
root: NodeId,
viewport: LayoutSize,
environment_epoch: u64,
immediate: Option<&mut crate::measurement::ImmediateHost<'_>>,
) -> Result<LayoutProgress, SurfaceError> {
self.ensure_mutable()?;
if self.measurements.environment_epoch() != Some(environment_epoch) {
for node in Rc::make_mut(&mut self.measurements).set_environment(environment_epoch) {
Rc::make_mut(&mut self.layout)
.invalidate_measurement(node)
.expect("measurement specs remain synchronized with layout nodes");
self.layout_dirty = true;
}
}
let inputs = LayoutInputs { root, viewport };
if !self.layout_dirty && self.last_inputs == Some(inputs) {
return if self.layout_provisional {
Ok(LayoutProgress::Provisional {
update: LayoutUpdate::default(),
requests: self.measurements.outstanding_requests(),
pending: self.measurements.pending_count(),
})
} else {
Ok(LayoutProgress::Complete(LayoutUpdate::default()))
};
}
for node in self.measurements.unresolved_nodes() {
Rc::make_mut(&mut self.layout)
.invalidate_measurement(node)
.expect("measurement consumers remain synchronized with layout nodes");
}
Rc::make_mut(&mut self.measurements).begin_pass();
let layout = Rc::make_mut(&mut self.layout);
let coordinator = Rc::<MeasurementCoordinator>::make_mut(&mut self.measurements);
let snapshot = match immediate {
Some(host) => layout.compute(
root,
viewport,
&mut crate::measurement::ImmediateMeasurer { coordinator, host },
),
None => layout.compute(root, viewport, coordinator),
}?;
let pass = Rc::make_mut(&mut self.measurements).finish_pass()?;
if pass.blocking {
self.layout_dirty = true;
return Ok(LayoutProgress::Blocked {
requests: pass.requests,
pending: pass.pending,
});
}
self.sync_text_presentations(&snapshot);
let update = self.project_layout(snapshot, inputs)?;
if pass.provisional || !pass.requests.is_empty() || pass.pending != 0 {
self.layout_provisional = true;
Ok(LayoutProgress::Provisional {
update,
requests: pass.requests,
pending: pass.pending,
})
} else {
self.layout_provisional = false;
Ok(LayoutProgress::Complete(update))
}
}
pub fn apply_measurement_responses(
&mut self,
responses: &[MeasurementResponse],
) -> Result<MeasurementApply, SurfaceError> {
self.ensure_mutable()?;
let apply = Rc::make_mut(&mut self.measurements).apply_batch(responses)?;
for node in apply.invalidated_nodes() {
Rc::make_mut(&mut self.layout)
.invalidate_measurement(*node)
.expect("response consumers remain synchronized with layout nodes");
}
self.layout_dirty |= !apply.invalidated_nodes().is_empty();
Ok(apply)
}
pub fn apply_measurement_ready(
&mut self,
ready: &MeasurementReady,
) -> Result<DeferredMeasurementApply, SurfaceError> {
self.ensure_mutable()?;
let apply = Rc::make_mut(&mut self.measurements).apply_ready(ready)?;
for node in apply.invalidated_nodes() {
Rc::make_mut(&mut self.layout)
.invalidate_measurement(*node)
.expect("deferred consumers remain synchronized with layout nodes");
}
self.layout_dirty |= !apply.invalidated_nodes().is_empty();
Ok(apply)
}
pub fn prepare_frame(
&mut self,
viewport_epoch: u32,
) -> Result<Option<&FramePacket>, SurfaceError> {
self.scene.prepare_frame(viewport_epoch).map_err(Into::into)
}
pub fn present<Sink: FrameSink>(
&mut self,
viewport_epoch: u32,
sink: &mut Sink,
) -> Result<Option<ApplyResult>, SurfacePresentError<Sink::Error>> {
let packet = self
.prepare_frame(viewport_epoch)
.map_err(SurfacePresentError::Surface)?
.cloned();
let Some(packet) = packet else {
return Ok(None);
};
let result = match sink.present(&packet) {
Ok(result) => result,
Err(error) => {
self.require_snapshot()
.expect("a prepared frame can always be replaced by a snapshot");
return Err(SurfacePresentError::Sink(error));
}
};
match result {
ApplyResult::Accepted { revision } => {
if let Err(error) = self.accept_pending(revision) {
self.require_snapshot()
.expect("a prepared frame can always be replaced by a snapshot");
return Err(SurfacePresentError::Surface(error));
}
}
ApplyResult::NeedSnapshot { .. } => self
.require_snapshot()
.map_err(SurfacePresentError::Surface)?,
}
Ok(Some(result))
}
pub fn accept_pending(&mut self, revision: u64) -> Result<(), SurfaceError> {
self.scene.accept_pending(revision).map_err(Into::into)
}
pub fn discard_pending(&mut self) -> Result<(), SurfaceError> {
self.scene.discard_pending().map_err(Into::into)
}
pub fn require_snapshot(&mut self) -> Result<(), SurfaceError> {
self.scene.require_snapshot().map_err(Into::into)
}
fn ensure_mutable(&self) -> Result<(), SurfaceError> {
if self.scene.has_prepared_frame() {
Err(SceneError::FramePending.into())
} else {
Ok(())
}
}
fn project_layout(
&mut self,
snapshot: LayoutSnapshot,
inputs: LayoutInputs,
) -> Result<LayoutUpdate, SurfaceError> {
let entries = snapshot
.iter()
.map(|(node, rect)| (node, *rect))
.collect::<Vec<_>>();
validate_layout_entries(&self.scene, &entries)?;
let changed = entries
.iter()
.copied()
.filter(|(node, rect)| {
self.last_layout
.as_ref()
.and_then(|previous| previous.get(*node))
!= Some(rect)
})
.collect::<Vec<_>>();
let transforms = changed
.iter()
.map(|(node, rect)| {
self.transforms
.get(node)
.map(|style| {
self.resolve_node_transform(
*node,
style,
rect.border_box.width,
rect.border_box.height,
)
})
.transpose()
.map(Option::flatten)
})
.collect::<Result<Vec<_>, SurfaceError>>()?;
let radial_backgrounds = if self.radial_backgrounds.is_empty() {
Vec::new()
} else {
changed
.iter()
.filter_map(|(node, geometry)| {
let sources = self.radial_backgrounds.get(node)?;
let mut layers = self
.scene
.node(*node)
.expect("radial background owners remain live")
.background_layers()
.to_vec();
canonicalize_radial_backgrounds(
&mut layers,
sources,
*geometry,
self.scene.node(*node).and_then(SceneNode::box_paint),
);
Some((*node, layers))
})
.collect::<Vec<_>>()
};
for ((node, rect), transform) in changed.iter().zip(transforms) {
self.scene
.set_layout(*node, *rect)
.expect("validated layout projection must enter a mutable synchronized scene");
if let Some(transform) = transform {
self.scene
.set_transform(*node, transform)
.expect("the transform was validated before layout projection");
}
}
for (node, layers) in radial_backgrounds {
self.scene
.set_background_layers(node, layers)
.expect("canonical radial backgrounds preserve protocol validity");
}
if snapshot.has_paragraph_suppression() || !self.paragraph_visibility.is_empty() {
Rc::make_mut(&mut self.paragraph_visibility).project(&mut self.scene, &snapshot);
}
self.last_layout = Some(Rc::new(snapshot));
self.last_inputs = Some(inputs);
self.layout_dirty = false;
Ok(LayoutUpdate::computed(changed.len()))
}
fn resolve_node_transform(
&self,
node: NodeId,
style: &ComputedTransformStyle,
border_width: f32,
border_height: f32,
) -> Result<Option<whisker_protocol::Transform>, SurfaceError> {
if style.perspective.is_none()
&& matches!(
style.offset_path,
whisker_style::ComputedOffsetPathValue::None
)
&& style.functions.is_empty()
&& self
.scene
.node(node)
.and_then(SceneNode::transform)
.is_none()
{
return Ok(None);
}
let transform = lower_transform(style, border_width, border_height)
.ok_or(SurfaceError::InvalidTransformOutput { node })?;
Ok(Some(transform))
}
fn sync_text_presentations(&mut self, snapshot: &whisker_layout::LayoutSnapshot) {
for (node, selection) in snapshot.selections() {
let Some((whisker_protocol::MeasurementPayload::Text(payload), metrics)) =
self.measurements.selected(node, selection)
else {
continue;
};
let Some(current) = self.scene.node(node).and_then(SceneNode::text) else {
continue;
};
let mut content = current.clone();
content.payload = payload.clone();
content.prepared_content = metrics.prepared_content;
content.paragraph = metrics.paragraph.clone();
self.scene
.set_text(node, content)
.expect("selected text remains valid");
}
}
}
fn collect_scene_subtree(
scene: &Scene,
node: NodeId,
output: &mut Vec<NodeId>,
) -> Result<(), SurfaceError> {
let retained = scene.node(node).ok_or(SceneError::UnknownNode { node })?;
output.push(node);
for child in retained.children() {
collect_scene_subtree(scene, *child, output)
.expect("retained scene children remain live while their parent is live");
}
Ok(())
}
fn validate_layout_entries(
scene: &Scene,
entries: &[(NodeId, LayoutGeometry)],
) -> Result<(), SurfaceError> {
for (node, geometry) in entries {
if scene.node(*node).is_none() {
return Err(SurfaceError::SceneLayoutMismatch { node: *node });
}
if !geometry.is_valid() {
return Err(SurfaceError::InvalidLayoutOutput { node: *node });
}
}
Ok(())
}
#[cfg(test)]
mod tests {
use std::cell::Cell;
use whisker_layout::{AvailableSpace, LayoutSize, MeasureRequest, UnsupportedLayoutFeature};
use whisker_protocol::{
ApplyResult, BackgroundAttachment, BackgroundLayer, BackgroundSize, BlendMode,
CustomMeasurePayload, ElementTypeId, EmbeddedSurfaceMeasurePayload, FrameMode,
HitTestBehavior, ImageRepeat, InputPoint, LayoutRect, MeasureFontFamily, MeasureFontStyle,
MeasureLineHeight, MeasureTextDirection, MeasureTextOverflow, MeasureTextWrap,
MeasuredSize, MeasurementKey, MeasurementKind, MeasurementMetrics, MeasurementPayload,
MeasurementReady, MeasurementRequestId, MeasurementResponse, MeasurementSpec,
NativeControlMeasurePayload, NodeId, Operation, PaintBox, PaintCoordinate, PaintImage,
PaintLengthPercentage, PaintPosition, PendingMeasurePolicy, PointerId,
RadialGradientExtent, RadialGradientShape, ReplacedContentMeasurePayload, ResourceId,
SurfaceId, TextMeasurePayload, TextMeasureStyle, UnsupportedMeasurementReason,
};
use whisker_style::{
Axes, ComputedLengthPercentage, ComputedSizeValue, ComputedTransformFunction,
ComputedTransformStyle, LengthPercentageValue, PositionValue, SpecifiedStyle,
StyleEnvironment, StyleNumber, StyleProperty, StyleValue, TransformFunctionValue,
TransformValue, resolve_style,
};
use super::*;
use crate::{FrameSink, RecordingRenderer};
#[test]
fn snapshots_share_unchanged_nodes_and_isolate_mutations() {
let mut surface = SurfaceEngine::new(surface_id());
let changed = surface
.create_node(element_type(), sized(40.0, 20.0))
.unwrap();
let untouched = surface
.create_node(element_type(), sized(10.0, 10.0))
.unwrap();
let snapshot = surface.clone();
surface.set_opacity(changed, 0.5).unwrap();
assert!(std::ptr::eq(
surface.node(untouched).unwrap(),
snapshot.node(untouched).unwrap()
));
assert!(!std::ptr::eq(
surface.node(changed).unwrap(),
snapshot.node(changed).unwrap()
));
assert_ne!(surface.node(changed), snapshot.node(changed));
}
#[test]
fn paint_updates_share_layout_and_measurement_snapshots() {
let initial =
resolve_style(&SpecifiedStyle::new(), None, StyleEnvironment::default()).unwrap();
let painted = resolve_style(
&SpecifiedStyle::new().push(
StyleProperty::Opacity,
StyleValue::Number(StyleNumber::new(0.5)),
),
None,
StyleEnvironment::default(),
)
.unwrap();
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), initial.computed().layout().clone())
.unwrap();
surface
.update_computed_style(root, initial.computed())
.unwrap();
surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 1)
.unwrap();
let snapshot = surface.clone();
surface
.update_computed_style(root, painted.computed())
.unwrap();
surface.set_measurement(root, None).unwrap();
surface.set_background_layers(root, Vec::new()).unwrap();
assert!(std::ptr::eq(surface.layout_tree(), snapshot.layout_tree()));
assert!(Rc::ptr_eq(&surface.measurements, &snapshot.measurements));
assert!(Rc::ptr_eq(&surface.transforms, &snapshot.transforms));
assert!(Rc::ptr_eq(
&surface.radial_backgrounds,
&snapshot.radial_backgrounds
));
assert!(std::ptr::eq(
surface.last_layout().unwrap(),
snapshot.last_layout().unwrap()
));
assert!(!surface.needs_layout());
surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 1)
.unwrap();
assert!(Rc::ptr_eq(&surface.measurements, &snapshot.measurements));
assert!(std::ptr::eq(surface.layout_tree(), snapshot.layout_tree()));
surface
.update_layout_style(root, sized(50.0, 50.0))
.unwrap();
assert!(!std::ptr::eq(surface.layout_tree(), snapshot.layout_tree()));
assert_eq!(
snapshot.layout_tree().style(root),
Some(initial.computed().layout())
);
assert_ne!(surface.node(root), snapshot.node(root));
}
fn surface_id() -> SurfaceId {
SurfaceId::new(1).expect("test surface")
}
fn element_type() -> ElementTypeId {
ElementTypeId::new(1).expect("test element type")
}
fn node_id(value: u64) -> NodeId {
NodeId::new(value).expect("test node")
}
fn sized(width: f32, height: f32) -> ComputedLayoutStyle {
ComputedLayoutStyle {
size: Axes {
width: ComputedSizeValue::Value(ComputedLengthPercentage::new(width, 0.0)),
height: ComputedSizeValue::Value(ComputedLengthPercentage::new(height, 0.0)),
},
..ComputedLayoutStyle::default()
}
}
fn resource_background(resource: u64) -> BackgroundLayer {
BackgroundLayer {
image: PaintImage::Resource(ResourceId::new(resource).expect("test resource")),
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 radial_background(
shape: RadialGradientShape,
extent: RadialGradientExtent,
radii: Option<(PaintLengthPercentage, PaintLengthPercentage)>,
) -> BackgroundLayer {
BackgroundLayer {
image: PaintImage::RadialGradient {
shape,
extent,
center: PaintPosition {
x: PaintCoordinate {
length: 0.0,
fraction: 0.5,
},
y: PaintCoordinate {
length: 0.0,
fraction: 0.5,
},
},
radii,
repeating: false,
stops: vec![
whisker_protocol::GradientStop {
color: Default::default(),
position: Some(PaintCoordinate {
length: 0.0,
fraction: 0.0,
}),
},
whisker_protocol::GradientStop {
color: Default::default(),
position: Some(PaintCoordinate {
length: 25.0,
fraction: 0.0,
}),
},
],
},
position: PaintPosition::default(),
size: BackgroundSize::Auto,
repeat_x: ImageRepeat::Repeat,
repeat_y: ImageRepeat::Repeat,
origin: PaintBox::Border,
clip: PaintBox::Border,
attachment: BackgroundAttachment::Scroll,
blend_mode: BlendMode::Normal,
}
}
type RadialParts<'a> = (
RadialGradientShape,
RadialGradientExtent,
Option<(PaintLengthPercentage, PaintLengthPercentage)>,
&'a [whisker_protocol::GradientStop],
);
fn radial_parts(image: &PaintImage) -> Option<RadialParts<'_>> {
match image {
PaintImage::RadialGradient {
shape,
extent,
radii,
stops,
..
} => Some((*shape, *extent, *radii, stops)),
_ => None,
}
}
#[test]
fn layout_canonicalizes_radial_keyword_geometry_and_absolute_stops() {
assert!(radial_parts(&PaintImage::None).is_none());
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), sized(200.0, 100.0))
.expect("root");
let plain_child = surface
.create_node(element_type(), sized(10.0, 10.0))
.expect("plain child");
surface.insert_child(root, plain_child, 0).expect("insert");
surface
.set_background_layers(
root,
vec![radial_background(
RadialGradientShape::Circle,
RadialGradientExtent::FarthestCorner,
None,
)],
)
.expect("background");
surface
.compute_layout(root, LayoutSize::new(200.0, 100.0), &mut zero_measure)
.expect("layout");
surface
.set_background_layers(
root,
vec![radial_background(
RadialGradientShape::Circle,
RadialGradientExtent::FarthestCorner,
None,
)],
)
.expect("post-layout background");
let (shape, extent, radii, stops) =
radial_parts(&surface.node(root).unwrap().background_layers()[0].image)
.expect("canonical radial gradient");
let (radius_x, radius_y) = radii.expect("canonical radii");
let expected_radius = 100.0_f32.hypot(50.0);
assert_eq!(shape, RadialGradientShape::Ellipse);
assert_eq!(extent, RadialGradientExtent::Explicit);
assert!((radius_x.length - expected_radius).abs() < 0.001);
assert_eq!(radius_x, radius_y);
assert_eq!(radius_x.fraction, 0.0);
assert_eq!(stops[1].position.unwrap().length, 0.0);
assert!((stops[1].position.unwrap().fraction - 25.0 / expected_radius).abs() < 0.0001);
surface
.update_layout_style(root, sized(100.0, 100.0))
.expect("resize style");
surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 1)
.expect("resized layout");
let (_, _, resized_radii, resized_stops) =
radial_parts(&surface.node(root).unwrap().background_layers()[0].image)
.expect("resized radial gradient");
let (resized_radius, _) = resized_radii.expect("resized radii");
let resized_expected = 50.0_f32.hypot(50.0);
assert!((resized_radius.length - resized_expected).abs() < 0.001);
assert!(
(resized_stops[1].position.unwrap().fraction - 25.0 / resized_expected).abs() < 0.0001
);
}
#[test]
fn clearing_radial_backgrounds_drops_retained_geometry_sources() {
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), sized(200.0, 100.0))
.unwrap();
surface
.set_background_layers(
root,
vec![radial_background(
RadialGradientShape::Circle,
RadialGradientExtent::FarthestCorner,
None,
)],
)
.unwrap();
surface
.compute_layout(root, LayoutSize::new(200.0, 100.0), &mut zero_measure)
.unwrap();
let snapshot = surface.clone();
surface.set_background_layers(root, Vec::new()).unwrap();
surface
.update_layout_style(root, sized(100.0, 100.0))
.unwrap();
surface
.compute_layout(root, LayoutSize::new(200.0, 100.0), &mut zero_measure)
.unwrap();
assert!(surface.node(root).unwrap().background_layers().is_empty());
assert_eq!(snapshot.node(root).unwrap().background_layers().len(), 1);
}
#[test]
fn radial_canonicalization_preserves_ellipse_aspect_ratio_and_circle_radius() {
let geometry = LayoutGeometry::from(LayoutRect {
width: 200.0,
height: 100.0,
..LayoutRect::default()
});
let mut layers = vec![
radial_background(
RadialGradientShape::Ellipse,
RadialGradientExtent::FarthestCorner,
None,
),
radial_background(
RadialGradientShape::Circle,
RadialGradientExtent::Explicit,
Some((absolute_length(20.0), absolute_length(20.0))),
),
];
let sources = radial_background_sources(&layers);
canonicalize_radial_backgrounds(&mut layers, &sources, geometry, None);
let (_, _, ellipse_radii, _) = radial_parts(&layers[0].image).expect("ellipse");
let (ellipse_x, ellipse_y) = ellipse_radii.expect("ellipse radii");
assert!((ellipse_x.length - 100.0 * 2.0_f32.sqrt()).abs() < 0.001);
assert!((ellipse_y.length - 50.0 * 2.0_f32.sqrt()).abs() < 0.001);
let (shape, _, circle_radii, _) = radial_parts(&layers[1].image).expect("circle");
let (circle_x, circle_y) = circle_radii.expect("circle radii");
assert_eq!(shape, RadialGradientShape::Ellipse);
assert_eq!(circle_x, absolute_length(20.0));
assert_eq!(circle_y, absolute_length(20.0));
}
fn zero_measure(_: NodeId, _: MeasureRequest) -> LayoutSize {
LayoutSize::default()
}
fn measurement_spec(
kind: MeasurementKind,
pending_policy: PendingMeasurePolicy,
) -> MeasurementSpec {
MeasurementSpec {
content_hash: 1,
style_hash: 2,
payload: measurement_payload(kind),
pending_policy,
}
}
fn measurement_payload(kind: MeasurementKind) -> MeasurementPayload {
match kind {
MeasurementKind::Text => MeasurementPayload::Text(TextMeasurePayload {
runs: Vec::new(),
attachments: Vec::new(),
text: "Hello, Whisker".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: Some("en-US".into()),
direction: MeasureTextDirection::LeftToRight,
alignment: whisker_protocol::MeasureTextAlignment::Start,
indent: Default::default(),
wrap: MeasureTextWrap::Wrap,
word_break: Default::default(),
max_lines: None,
overflow: MeasureTextOverflow::Clip,
}),
MeasurementKind::ReplacedContent => {
MeasurementPayload::ReplacedContent(ReplacedContentMeasurePayload::default())
}
MeasurementKind::NativeControl => {
MeasurementPayload::NativeControl(NativeControlMeasurePayload {
control_type: 1,
version: 1,
state: Vec::new(),
})
}
MeasurementKind::EmbeddedSurface => {
MeasurementPayload::EmbeddedSurface(EmbeddedSurfaceMeasurePayload {
surface: SurfaceId::new(2).expect("child surface"),
preferred_size: None,
})
}
MeasurementKind::Custom { version } => {
MeasurementPayload::Custom(CustomMeasurePayload {
version,
data: whisker_protocol::WhiskerValue::Bytes(Vec::new()),
})
}
}
}
fn measurement_metrics(width: f32, height: f32) -> MeasurementMetrics {
MeasurementMetrics::from_size(MeasuredSize::new(width, height))
}
fn present_and_accept(
surface: &mut SurfaceEngine,
renderer: &mut RecordingRenderer,
viewport_epoch: u32,
) -> FramePacket {
let packet = surface
.prepare_frame(viewport_epoch)
.expect("prepare frame")
.expect("pending work")
.clone();
let revision = packet.header.target_revision;
assert_eq!(
renderer.present(&packet),
Ok(ApplyResult::Accepted { revision })
);
surface.accept_pending(revision).expect("accept frame");
packet
}
fn layout_operation_count(packet: &FramePacket) -> usize {
packet
.operations
.iter()
.filter(|operation| matches!(operation, Operation::SetLayout { .. }))
.count()
}
#[test]
fn layout_snapshot_projects_only_changed_geometry_into_frames() {
let mut surface = SurfaceEngine::new(surface_id());
assert_eq!(surface.surface(), surface_id());
assert!(surface.scene().has_pending_work());
assert!(surface.has_pending_work());
assert!(surface.layout_tree().is_empty());
assert_eq!(surface.last_layout(), None);
assert!(!surface.needs_layout());
assert_eq!(LayoutUpdate::default().changed_nodes(), 0);
assert!(!LayoutUpdate::default().recomputed());
assert_eq!(
zero_measure(
node_id(1),
MeasureRequest {
known_dimensions: [None, None],
available_space: [AvailableSpace::MaxContent; 2],
},
),
LayoutSize::default()
);
let root = surface
.create_node(element_type(), sized(100.0, 20.0))
.unwrap();
let left = surface
.create_node(element_type(), sized(10.0, 10.0))
.unwrap();
let right = surface
.create_node(element_type(), sized(10.0, 10.0))
.unwrap();
surface.insert_child(root, left, 0).unwrap();
surface.insert_child(root, right, 1).unwrap();
assert_eq!(surface.node(root).unwrap().children(), [left, right]);
assert_eq!(surface.layout_tree().len(), 3);
assert!(surface.needs_layout());
let first = surface
.compute_layout(root, LayoutSize::new(100.0, 20.0), &mut zero_measure)
.unwrap();
assert!(first.recomputed());
assert_eq!(first.changed_nodes(), 3);
assert!(!surface.needs_layout());
assert_eq!(surface.last_layout().unwrap().len(), 3);
let mut renderer = RecordingRenderer::new(surface_id());
let snapshot = present_and_accept(&mut surface, &mut renderer, 1);
assert_eq!(snapshot.header.mode, FrameMode::Snapshot);
assert_eq!(layout_operation_count(&snapshot), 3);
assert!(!surface.has_pending_work());
let idle = surface
.compute_layout(root, LayoutSize::new(100.0, 20.0), &mut zero_measure)
.unwrap();
assert!(!idle.recomputed());
assert_eq!(idle.changed_nodes(), 0);
assert!(surface.prepare_frame(2).unwrap().is_none());
let impact = surface
.update_layout_style(left, sized(20.0, 10.0))
.unwrap();
assert!(impact.contains(PropertyImpactSet::LAYOUT));
let changed = surface
.compute_layout(root, LayoutSize::new(100.0, 20.0), &mut zero_measure)
.unwrap();
assert!(changed.recomputed());
assert_eq!(changed.changed_nodes(), 2);
let delta = present_and_accept(&mut surface, &mut renderer, 2);
assert_eq!(delta.header.mode, FrameMode::Delta);
assert_eq!(layout_operation_count(&delta), 2);
}
#[test]
fn transform_style_projects_before_and_after_layout_and_rejects_invalid_matrices() {
let resolved = |function| {
resolve_style(
&SpecifiedStyle::new().push(
StyleProperty::Transform,
StyleValue::Transform(TransformValue(vec![function])),
),
None,
StyleEnvironment::default(),
)
.unwrap()
};
let translated = resolved(TransformFunctionValue::TranslateX(
LengthPercentageValue::Percentage(StyleNumber::new(50.0)),
));
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), translated.computed().layout().clone())
.unwrap();
surface
.update_computed_style(root, translated.computed())
.unwrap();
assert_eq!(surface.node(root).unwrap().transform(), None);
surface
.compute_layout(root, LayoutSize::new(40.0, 20.0), &mut zero_measure)
.unwrap();
let projected = surface.node(root).unwrap().transform().unwrap();
assert_eq!(projected.0[12], 20.0);
let rotated = resolved(TransformFunctionValue::Rotate(
StyleNumber::new(90.0).into(),
));
assert!(
surface
.update_computed_style(root, rotated.computed())
.unwrap()
.contains(PropertyImpactSet::PAINT)
);
assert_ne!(surface.node(root).unwrap().transform(), Some(projected));
let huge = resolved(TransformFunctionValue::Matrix([
StyleNumber::new(f32::MAX),
StyleNumber::new(0.0),
StyleNumber::new(0.0),
StyleNumber::new(1.0),
StyleNumber::new(0.0),
StyleNumber::new(0.0),
]));
assert_eq!(
surface.update_computed_style(root, huge.computed()),
Err(SurfaceError::InvalidTransformOutput { node: root })
);
let mut values = [StyleNumber::new(0.0); 16];
values[0] = StyleNumber::new(f32::NAN);
let invalid = ComputedTransformStyle {
functions: vec![ComputedTransformFunction::Matrix(values)],
..ComputedTransformStyle::default()
};
assert_eq!(
surface.resolve_node_transform(root, &invalid, 40.0, 20.0),
Err(SurfaceError::InvalidTransformOutput { node: root })
);
let mut invalid_projection = SurfaceEngine::new(surface_id());
let invalid_root = invalid_projection
.create_node(element_type(), sized(40.0, 20.0))
.unwrap();
Rc::make_mut(&mut invalid_projection.transforms).insert(invalid_root, invalid.clone());
assert_eq!(
invalid_projection.compute_layout(
invalid_root,
LayoutSize::new(40.0, 20.0),
&mut zero_measure,
),
Err(SurfaceError::InvalidTransformOutput { node: invalid_root })
);
let mut empty_surface = SurfaceEngine::new(surface_id());
let empty = empty_surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
assert_eq!(
empty_surface
.resolve_node_transform(empty, &ComputedTransformStyle::default(), 1.0, 1.0)
.unwrap(),
None
);
empty_surface
.set_transform(empty, whisker_protocol::Transform::IDENTITY)
.unwrap();
assert_eq!(
empty_surface.set_transform(node_id(99), whisker_protocol::Transform::IDENTITY),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: node_id(99)
}))
);
assert_eq!(
empty_surface
.resolve_node_transform(empty, &ComputedTransformStyle::default(), 1.0, 1.0)
.unwrap(),
Some(whisker_protocol::Transform::IDENTITY)
);
let point = |x, y| whisker_style::MotionPathPointValue {
x: StyleNumber::new(x),
y: StyleNumber::new(y),
};
let motion = ComputedTransformStyle {
offset_path: whisker_style::ComputedOffsetPathValue::Path(vec![
whisker_style::MotionPathCommandValue::MoveTo(point(0.0, 0.0)),
whisker_style::MotionPathCommandValue::LineTo(point(10.0, 0.0)),
]),
offset_distance: StyleNumber::new(0.5),
..ComputedTransformStyle::default()
};
assert_eq!(
empty_surface
.resolve_node_transform(empty, &motion, 1.0, 1.0)
.unwrap()
.unwrap()
.0[12],
5.0
);
}
#[test]
fn computed_paint_and_input_wrappers_share_the_retained_scene() {
let resolved = resolve_style(
&SpecifiedStyle::new(),
None,
StyleEnvironment::new(100.0, 100.0, 1.0, 14.0),
)
.unwrap();
let style = resolved.computed();
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), style.layout().clone())
.unwrap();
let missing = node_id(99);
let background = resource_background(1);
surface
.set_background_layers(root, vec![background.clone()])
.unwrap();
assert_eq!(
surface.node(root).unwrap().background_layers(),
std::slice::from_ref(&background)
);
assert_eq!(
surface.set_background_layers(missing, vec![background]),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
let mut invalid_background = resource_background(2);
invalid_background.position.x = PaintCoordinate {
length: f32::NAN,
fraction: 0.0,
};
assert_eq!(
surface.set_background_layers(root, vec![invalid_background]),
Err(SurfaceError::Scene(SceneError::InvalidBackgroundLayers))
);
assert_eq!(
surface.update_computed_style(missing, style),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
let first = surface.update_computed_style(root, style).unwrap();
assert!(first.contains(PropertyImpactSet::PAINT));
let lowered = lower_paint(style.paint(), style.layout());
let node = surface.node(root).unwrap();
assert_eq!(node.box_paint(), Some(&lowered.box_paint));
assert_eq!(node.clip(), Some(lowered.clip));
assert_eq!(node.opacity(), Some(lowered.opacity));
assert_eq!(node.visibility(), Some(lowered.visibility));
assert_eq!(node.z_order(), Some(lowered.z_order));
assert_eq!(node.hit_test(), Some(HitTestBehavior::Auto));
assert_eq!(
node.cursor().map(|cursor| cursor.fallback),
Some(whisker_protocol::CursorKeyword::Auto)
);
surface.set_opacity(root, 0.5).unwrap();
assert_eq!(surface.node(root).unwrap().opacity(), Some(0.5));
assert_eq!(
surface.set_opacity(missing, 0.5),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
surface.set_opacity(root, lowered.opacity).unwrap();
assert!(
surface
.update_computed_style(root, style)
.unwrap()
.is_empty()
);
let mut different_box = lowered.box_paint.clone();
different_box.background_color = whisker_protocol::PaintColor::Named("changed".into());
surface.set_box_paint(root, different_box).unwrap();
assert!(
surface
.update_computed_style(root, style)
.unwrap()
.contains(PropertyImpactSet::PAINT)
);
surface
.set_plain_text(root, &PlainTextInput::new("animated"), style)
.unwrap();
surface.set_text_style(root, style).unwrap();
let text_style = lower_text_style(style);
assert_eq!(surface.node(root).unwrap().text_style(), Some(&text_style));
surface
.set_text_style_snapshot(root, text_style.clone())
.unwrap();
assert_eq!(
surface.set_text_style(missing, style),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
assert_eq!(
surface.set_text_style_snapshot(missing, text_style),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
let mut text = surface.node(root).unwrap().text().unwrap().clone();
text.paint.foreground = whisker_protocol::PaintColor::Srgba {
red: 255,
green: 0,
blue: 0,
alpha: 1.0,
};
surface.set_text_content(root, text.clone()).unwrap();
assert_eq!(surface.node(root).unwrap().text(), Some(&text));
assert_eq!(
surface.set_text_content(missing, text),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
surface
.scene
.set_clip(
root,
whisker_protocol::BoxClip {
horizontal: whisker_protocol::OverflowClip::Hidden,
vertical: whisker_protocol::OverflowClip::Hidden,
},
)
.unwrap();
assert!(
surface
.update_computed_style(root, style)
.unwrap()
.contains(PropertyImpactSet::PAINT)
);
surface.scene.set_opacity(root, 0.25).unwrap();
assert!(
surface
.update_computed_style(root, style)
.unwrap()
.contains(PropertyImpactSet::PAINT)
);
surface
.scene
.set_visibility(root, whisker_protocol::Visibility::Hidden)
.unwrap();
assert!(
surface
.update_computed_style(root, style)
.unwrap()
.contains(PropertyImpactSet::PAINT)
);
surface.scene.set_z_order(root, 7).unwrap();
assert!(
surface
.update_computed_style(root, style)
.unwrap()
.contains(PropertyImpactSet::PAINT)
);
let point = InputPoint { x: 5.0, y: 5.0 };
assert_eq!(surface.hit_test(root, point), Ok(None));
surface
.scene
.set_layout(
root,
whisker_protocol::LayoutRect {
x: 0.0,
y: 0.0,
width: 10.0,
height: 10.0,
},
)
.unwrap();
assert_eq!(surface.hit_test(root, point), Ok(Some(root)));
assert_eq!(
surface.hit_test(missing, point),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
assert_eq!(surface.update_host_scroll_offset(root, [1.0, 2.0]), Ok(()));
assert_eq!(
surface.update_host_scroll_offset(root, [f32::NAN, 0.0]),
Err(SurfaceError::Scene(SceneError::NonFiniteNumber))
);
assert_eq!(
surface.update_host_scroll_offset(missing, [0.0, 0.0]),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
surface.set_event_mask(root, 5).unwrap();
assert_eq!(surface.node(root).unwrap().event_mask(), Some(5));
assert_eq!(
surface.set_event_mask(missing, 1),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
let accessibility = Accessibility::new().label("Interactive content");
surface
.set_accessibility(root, accessibility.clone())
.unwrap();
assert_eq!(
surface.node(root).unwrap().accessibility(),
Some(&accessibility)
);
assert_eq!(
surface.set_accessibility(missing, Accessibility::new()),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
let property = PropertyId::new(1).unwrap();
assert_eq!(
surface.set_property(root, property, WhiskerValue::Bool(true)),
Ok(())
);
assert_eq!(
surface.set_property(missing, property, WhiskerValue::Bool(false)),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
assert_eq!(surface.clear_property(root, property), Ok(()));
assert_eq!(
surface.clear_property(missing, property),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
let command = CommandId::new(1).unwrap();
assert_eq!(
surface.invoke_command(root, command, WhiskerValue::Null),
Ok(())
);
assert_eq!(
surface.invoke_command(missing, command, WhiskerValue::Null),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
surface.set_hit_test(root, HitTestBehavior::None).unwrap();
assert_eq!(surface.hit_test(root, point), Ok(None));
assert_eq!(
surface.set_hit_test(missing, HitTestBehavior::Auto),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
let cursor = whisker_protocol::Cursor {
resources: Vec::new(),
fallback: whisker_protocol::CursorKeyword::Pointer,
};
surface.set_cursor(root, cursor.clone()).unwrap();
assert_eq!(surface.node(root).unwrap().cursor(), Some(&cursor));
assert_eq!(
surface.set_cursor(missing, cursor),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: missing
}))
);
let pointer = PointerId::new(1).unwrap();
assert_eq!(surface.pointer_capture_target(pointer), None);
surface.scene.set_pointer_capture(root, pointer).unwrap();
assert_eq!(surface.pointer_capture_target(pointer), Some(root));
let unsupported = resolve_style(
&SpecifiedStyle::new().push(
whisker_style::StyleProperty::Position,
whisker_style::StyleValue::Position(PositionValue::Sticky),
),
None,
StyleEnvironment::default(),
)
.unwrap();
assert_eq!(
surface.update_computed_style(root, unsupported.computed()),
Err(SurfaceError::Layout(LayoutError::UnsupportedStyle(
UnsupportedLayoutFeature::StickyPosition
)))
);
}
#[test]
fn pointer_input_lowering_covers_every_retained_keyword() {
assert_eq!(
lower_hit_test(PointerEventsValue::Auto),
HitTestBehavior::Auto
);
assert_eq!(
lower_hit_test(PointerEventsValue::None),
HitTestBehavior::None
);
for (value, expected) in [
(CursorValue::Auto, CursorKeyword::Auto),
(CursorValue::Default, CursorKeyword::Default),
(CursorValue::None, CursorKeyword::None),
(CursorValue::ContextMenu, CursorKeyword::ContextMenu),
(CursorValue::Help, CursorKeyword::Help),
(CursorValue::Pointer, CursorKeyword::Pointer),
(CursorValue::Progress, CursorKeyword::Progress),
(CursorValue::Wait, CursorKeyword::Wait),
(CursorValue::Cell, CursorKeyword::Cell),
(CursorValue::Crosshair, CursorKeyword::Crosshair),
(CursorValue::Text, CursorKeyword::Text),
(CursorValue::VerticalText, CursorKeyword::VerticalText),
(CursorValue::Alias, CursorKeyword::Alias),
(CursorValue::Copy, CursorKeyword::Copy),
(CursorValue::Move, CursorKeyword::Move),
(CursorValue::NoDrop, CursorKeyword::NoDrop),
(CursorValue::NotAllowed, CursorKeyword::NotAllowed),
(CursorValue::Grab, CursorKeyword::Grab),
(CursorValue::Grabbing, CursorKeyword::Grabbing),
(CursorValue::ColResize, CursorKeyword::ColResize),
(CursorValue::RowResize, CursorKeyword::RowResize),
(CursorValue::NResize, CursorKeyword::NResize),
(CursorValue::EResize, CursorKeyword::EResize),
(CursorValue::SResize, CursorKeyword::SResize),
(CursorValue::WResize, CursorKeyword::WResize),
(CursorValue::NeResize, CursorKeyword::NeResize),
(CursorValue::NwResize, CursorKeyword::NwResize),
(CursorValue::SeResize, CursorKeyword::SeResize),
(CursorValue::SwResize, CursorKeyword::SwResize),
(CursorValue::EwResize, CursorKeyword::EwResize),
(CursorValue::NsResize, CursorKeyword::NsResize),
(CursorValue::NeswResize, CursorKeyword::NeswResize),
(CursorValue::NwseResize, CursorKeyword::NwseResize),
(CursorValue::ZoomIn, CursorKeyword::ZoomIn),
(CursorValue::ZoomOut, CursorKeyword::ZoomOut),
] {
assert_eq!(
lower_cursor(value),
Cursor {
resources: Vec::new(),
fallback: expected,
}
);
}
}
#[test]
fn structural_operations_keep_scene_and_layout_in_lockstep() {
let mut surface = SurfaceEngine::new(surface_id());
let unsupported = ComputedLayoutStyle {
position: PositionValue::Fixed,
..ComputedLayoutStyle::default()
};
assert_eq!(
surface.create_node(element_type(), unsupported),
Err(SurfaceError::Layout(LayoutError::UnsupportedStyle(
UnsupportedLayoutFeature::FixedPosition
)))
);
assert_eq!(surface.scene().node_count(), 0);
assert!(surface.layout_tree().is_empty());
let root = surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
assert_eq!(root, node_id(1));
let first = surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
let second = surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
let grandchild = surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
let unknown = node_id(99);
assert_eq!(
surface.insert_child(root, unknown, 0),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: unknown
}))
);
assert_eq!(
surface.remove_child(root, second),
Err(SurfaceError::Scene(SceneError::NotDirectChild {
parent: root,
child: second,
}))
);
surface.insert_child(root, first, 0).unwrap();
surface.insert_child(root, second, 1).unwrap();
surface.insert_child(first, grandchild, 0).unwrap();
assert_eq!(
surface.move_child(root, second, 2),
Err(SurfaceError::Scene(SceneError::ChildIndexOutOfBounds {
parent: root,
index: 2,
len: 1,
}))
);
surface.move_child(root, second, 0).unwrap();
assert_eq!(surface.node(root).unwrap().children(), [second, first]);
surface.remove_child(root, second).unwrap();
assert_eq!(surface.node(second).unwrap().parent(), None);
surface.insert_child(first, second, 1).unwrap();
assert_eq!(
surface.node(first).unwrap().children(),
[grandchild, second]
);
surface.delete_node(first).unwrap();
assert_eq!(surface.scene().node_count(), 1);
assert_eq!(surface.layout_tree().len(), 1);
assert!(!surface.layout_tree().contains(first));
assert!(!surface.layout_tree().contains(second));
assert!(!surface.layout_tree().contains(grandchild));
assert_eq!(
surface.delete_node(unknown),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: unknown
}))
);
assert_eq!(
surface.set_measurable(unknown, true),
Err(SurfaceError::Layout(LayoutError::UnknownNode(unknown)))
);
}
#[test]
fn measurement_and_impact_invalidation_schedule_only_required_layout() {
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
assert!(surface.set_measurable(root, true).unwrap());
assert!(!surface.set_measurable(root, true).unwrap());
let calls = Cell::new(0);
let mut measure = |_: NodeId, _: MeasureRequest| {
calls.set(calls.get() + 1);
LayoutSize::new(12.0, 8.0)
};
let first = surface
.compute_layout(root, LayoutSize::new(100.0, 100.0), &mut measure)
.unwrap();
assert_eq!(first.changed_nodes(), 1);
let first_pass_calls = calls.get();
assert!(first_pass_calls > 0);
let mut renderer = RecordingRenderer::new(surface_id());
present_and_accept(&mut surface, &mut renderer, 1);
assert!(
!surface
.invalidate_node(root, PropertyImpactSet::PAINT)
.unwrap()
);
assert!(!surface.needs_layout());
let skipped = surface
.compute_layout(root, LayoutSize::new(100.0, 100.0), &mut measure)
.unwrap();
assert!(!skipped.recomputed());
assert_eq!(calls.get(), first_pass_calls);
assert!(
surface
.invalidate_node(root, PropertyImpactSet::TEXT_METRICS)
.unwrap()
);
let measured = surface
.compute_layout(root, LayoutSize::new(100.0, 100.0), &mut measure)
.unwrap();
assert!(measured.recomputed());
assert_eq!(measured.changed_nodes(), 0);
let invalidated_pass_calls = calls.get();
assert!(invalidated_pass_calls > first_pass_calls);
assert!(surface.prepare_frame(2).unwrap().is_none());
assert_eq!(
surface.invalidate_node(node_id(99), PropertyImpactSet::LAYOUT),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: node_id(99)
}))
);
surface
.invalidate_node(root, PropertyImpactSet::TEXT_METRICS)
.unwrap();
assert_eq!(
surface.compute_layout(root, LayoutSize::new(100.0, 100.0), &mut |_, _| {
LayoutSize::new(f32::NAN, 1.0)
},),
Err(SurfaceError::Layout(LayoutError::InvalidMeasurement(root)))
);
assert!(surface.needs_layout());
surface
.compute_layout(root, LayoutSize::new(100.0, 100.0), &mut measure)
.unwrap();
assert!(calls.get() > invalidated_pass_calls);
let equal = surface
.update_layout_style(root, ComputedLayoutStyle::default())
.unwrap();
assert!(equal.is_empty());
assert!(!surface.needs_layout());
let viewport_change = surface
.compute_layout(root, LayoutSize::new(200.0, 100.0), &mut measure)
.unwrap();
assert!(viewport_change.recomputed());
let unsupported = ComputedLayoutStyle {
position: PositionValue::Sticky,
..ComputedLayoutStyle::default()
};
assert_eq!(
surface.update_layout_style(root, unsupported),
Err(SurfaceError::Layout(LayoutError::UnsupportedStyle(
UnsupportedLayoutFeature::StickyPosition
)))
);
assert!(!surface.needs_layout());
assert!(surface.set_measurable(root, false).unwrap());
}
#[test]
fn host_measurement_blocks_batches_caches_and_completes_layout() {
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
assert_eq!(surface.last_measurement(root), None);
assert_eq!(
surface.set_measurement(node_id(99), None),
Err(SurfaceError::Scene(SceneError::UnknownNode {
node: node_id(99)
}))
);
assert!(
surface
.set_measurement(
root,
Some(measurement_spec(
MeasurementKind::Text,
PendingMeasurePolicy::Block,
)),
)
.unwrap()
);
assert!(
!surface
.set_measurement(
root,
Some(measurement_spec(
MeasurementKind::Text,
PendingMeasurePolicy::Block,
)),
)
.unwrap()
);
let blocked = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 1)
.unwrap();
assert!(!blocked.has_layout());
assert!(!blocked.requests().is_empty());
assert_eq!(surface.last_layout(), None);
let initial_requests = blocked.requests().to_vec();
let repeated = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 1)
.unwrap();
assert_eq!(repeated.requests(), initial_requests);
let stale = surface
.apply_measurement_responses(&[MeasurementResponse::Ready {
key: MeasurementKey::new(99).expect("stale key"),
environment_epoch: 1,
metrics: measurement_metrics(1.0, 1.0),
}])
.unwrap();
assert_eq!(stale.applied(), 0);
assert_eq!(stale.stale(), 1);
assert!(surface.needs_layout());
let initial_responses = initial_requests
.iter()
.map(|request| MeasurementResponse::Ready {
key: request.key,
environment_epoch: 1,
metrics: measurement_metrics(24.0, 12.0),
})
.collect::<Vec<_>>();
let applied = surface
.apply_measurement_responses(&initial_responses)
.unwrap();
assert_eq!(applied.applied(), initial_responses.len());
let complete = loop {
let progress = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 1)
.unwrap();
if progress.requests().is_empty() {
break progress;
}
let responses = progress
.requests()
.iter()
.map(|request| MeasurementResponse::Ready {
key: request.key,
environment_epoch: 1,
metrics: measurement_metrics(24.0, 12.0),
})
.collect::<Vec<_>>();
surface.apply_measurement_responses(&responses).unwrap();
};
assert!(complete.has_layout());
assert!(complete.requests().is_empty());
assert_eq!(
complete,
LayoutProgress::Complete(LayoutUpdate::computed(1))
);
assert_eq!(
surface.last_measurement(root),
Some(&measurement_metrics(24.0, 12.0))
);
let idle = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 1)
.unwrap();
assert_eq!(idle, LayoutProgress::Complete(LayoutUpdate::default()));
assert!(idle.requests().is_empty());
assert!(surface.set_measurement(root, None).unwrap());
assert!(!surface.set_measurement(root, None).unwrap());
assert_eq!(surface.last_measurement(root), None);
}
#[test]
fn provisional_resource_measurement_relayouts_after_deferred_completion() {
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
surface
.set_measurement(
root,
Some(measurement_spec(
MeasurementKind::ReplacedContent,
PendingMeasurePolicy::Placeholder(MeasuredSize::new(16.0, 9.0)),
)),
)
.unwrap();
let provisional = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 7)
.unwrap();
assert!(provisional.has_layout());
assert!(!provisional.requests().is_empty());
let initial_requests = provisional.requests().to_vec();
let idle = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 7)
.unwrap();
assert_eq!(idle.requests(), initial_requests);
let mut pending_measurements = Vec::new();
let mut progress = provisional;
let pending = loop {
let requests = progress.requests().to_vec();
if requests.is_empty() {
break progress;
}
let responses = requests
.iter()
.map(|request| {
let request_id = MeasurementRequestId::new(100 + request.key.get())
.expect("pending request ID");
pending_measurements.push((request.key, request_id));
MeasurementResponse::Pending {
key: request.key,
environment_epoch: 7,
request_id,
provisional: Some(measurement_metrics(20.0, 10.0)),
}
})
.collect::<Vec<_>>();
surface.apply_measurement_responses(&responses).unwrap();
progress = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 7)
.unwrap();
};
assert!(matches!(
pending,
LayoutProgress::Provisional {
update,
requests,
pending,
} if update.recomputed() && requests.is_empty() && pending > 0
));
let idle_pending = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 7)
.unwrap();
assert!(matches!(
idle_pending,
LayoutProgress::Provisional {
update,
requests,
pending,
} if update == LayoutUpdate::default()
&& requests.is_empty()
&& pending > 0
));
let (key, request_id) = pending_measurements[0];
let invalid_ready = MeasurementReady {
key,
request_id,
environment_epoch: 7,
metrics: measurement_metrics(f32::NAN, 1.0),
};
assert_eq!(
surface.apply_measurement_ready(&invalid_ready),
Err(SurfaceError::Measurement(
MeasurementError::InvalidMetrics { key }
))
);
let stale = MeasurementReady {
key: MeasurementKey::new(key.get() + 10_000).expect("wrong key"),
request_id,
environment_epoch: 7,
metrics: measurement_metrics(32.0, 18.0),
};
assert_eq!(
surface.apply_measurement_ready(&stale).unwrap(),
DeferredMeasurementApply::IgnoredStale
);
assert!(!surface.needs_layout());
let ready = MeasurementReady { key, ..stale };
assert_eq!(
surface.apply_measurement_ready(&ready).unwrap(),
DeferredMeasurementApply::Applied {
invalidated_nodes: vec![root]
}
);
assert!(surface.needs_layout());
for (key, request_id) in pending_measurements.into_iter().skip(1) {
assert_eq!(
surface
.apply_measurement_ready(&MeasurementReady {
key,
request_id,
environment_epoch: 7,
metrics: measurement_metrics(32.0, 18.0),
})
.unwrap(),
DeferredMeasurementApply::Applied {
invalidated_nodes: vec![root]
}
);
}
let complete = loop {
let progress = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 7)
.unwrap();
if progress.requests().is_empty() {
break progress;
}
let responses = progress
.requests()
.iter()
.map(|request| MeasurementResponse::Ready {
key: request.key,
environment_epoch: 7,
metrics: measurement_metrics(32.0, 18.0),
})
.collect::<Vec<_>>();
surface.apply_measurement_responses(&responses).unwrap();
};
assert!(matches!(complete, LayoutProgress::Complete(update) if update.recomputed()));
assert_eq!(
surface.last_measurement(root),
Some(&measurement_metrics(32.0, 18.0))
);
let new_environment = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 8)
.unwrap();
assert!(new_environment.has_layout());
assert!(!new_environment.requests().is_empty());
}
#[test]
fn invalid_and_unsupported_measurement_surface_diagnostics() {
assert_eq!(
measurement_spec(
MeasurementKind::EmbeddedSurface,
PendingMeasurePolicy::Block
)
.payload
.kind(),
MeasurementKind::EmbeddedSurface
);
assert_eq!(
measurement_spec(
MeasurementKind::Custom { version: 1 },
PendingMeasurePolicy::Block
)
.payload
.kind(),
MeasurementKind::Custom { version: 1 }
);
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
let invalid = measurement_spec(
MeasurementKind::NativeControl,
PendingMeasurePolicy::Placeholder(MeasuredSize::new(f32::NAN, 1.0)),
);
assert_eq!(
surface.set_measurement(root, Some(invalid)),
Err(SurfaceError::Measurement(
MeasurementError::InvalidPlaceholder { node: root }
))
);
surface
.set_measurement(
root,
Some(measurement_spec(
MeasurementKind::NativeControl,
PendingMeasurePolicy::Block,
)),
)
.unwrap();
let blocked = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 1)
.unwrap();
let request = blocked.requests()[0].clone();
assert_eq!(
surface.apply_measurement_responses(&[MeasurementResponse::Ready {
key: request.key,
environment_epoch: 1,
metrics: measurement_metrics(f32::NAN, 1.0),
}]),
Err(SurfaceError::Measurement(
MeasurementError::InvalidMetrics { key: request.key }
))
);
surface
.apply_measurement_responses(&[MeasurementResponse::Unsupported {
key: request.key,
environment_epoch: 1,
reason: UnsupportedMeasurementReason::Environment,
}])
.unwrap();
let error = surface
.compute_layout_with_measurements(root, LayoutSize::new(100.0, 100.0), 1)
.unwrap_err();
assert_eq!(
error,
SurfaceError::Measurement(MeasurementError::Unsupported {
node: root,
reason: UnsupportedMeasurementReason::Environment,
})
);
assert!(error.source().is_some());
assert_eq!(
format!("{}", MeasurementError::KeyExhausted),
"Whisker measurement error: KeyExhausted"
);
}
#[test]
fn prepared_frame_blocks_every_layout_mutation_until_resolved() {
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
let computed =
resolve_style(&SpecifiedStyle::new(), None, StyleEnvironment::default()).unwrap();
let lowered = lower_paint(computed.computed().paint(), computed.computed().layout());
let pending = surface.prepare_frame(1).unwrap().unwrap().clone();
assert!(surface.scene().has_prepared_frame());
assert_eq!(
surface.create_node(element_type(), ComputedLayoutStyle::default()),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.update_layout_style(root, ComputedLayoutStyle::default()),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.update_computed_style(root, computed.computed()),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.scene.set_box_paint(root, lowered.box_paint),
Err(SceneError::FramePending)
);
assert_eq!(
surface.set_background_layers(root, vec![resource_background(1)]),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface
.scene
.set_background_layers(root, vec![resource_background(1)]),
Err(SceneError::FramePending)
);
assert_eq!(
surface.scene.set_clip(root, lowered.clip),
Err(SceneError::FramePending)
);
assert_eq!(
surface.set_cursor(
root,
Cursor {
resources: Vec::new(),
fallback: CursorKeyword::Pointer,
},
),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.set_measurable(root, true),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.set_measurement(root, None),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.invalidate_node(root, PropertyImpactSet::LAYOUT),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.compute_layout(root, LayoutSize::new(1.0, 1.0), &mut zero_measure),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.compute_layout_with_measurements(root, LayoutSize::new(1.0, 1.0), 1),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.apply_measurement_responses(&[]),
Err(SurfaceError::Scene(SceneError::FramePending))
);
let fake_ready = MeasurementReady {
key: MeasurementKey::new(1).expect("key"),
request_id: MeasurementRequestId::new(1).expect("request"),
environment_epoch: 1,
metrics: measurement_metrics(1.0, 1.0),
};
assert_eq!(
surface.apply_measurement_ready(&fake_ready),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.delete_node(root),
Err(SurfaceError::Scene(SceneError::FramePending))
);
assert_eq!(
surface.prepare_frame(1),
Err(SurfaceError::Scene(SceneError::FramePending))
);
surface.discard_pending().unwrap();
assert!(!surface.scene().has_prepared_frame());
let retried = surface.prepare_frame(1).unwrap().unwrap().clone();
assert!(retried.header.frame_id > pending.header.frame_id);
surface.require_snapshot().unwrap();
assert!(!surface.scene().has_prepared_frame());
let mut renderer = RecordingRenderer::new(surface_id());
let snapshot = present_and_accept(&mut surface, &mut renderer, 1);
assert_eq!(snapshot.header.mode, FrameMode::Snapshot);
assert_eq!(
surface.accept_pending(snapshot.header.target_revision),
Err(SurfaceError::Scene(SceneError::NoPendingFrame))
);
assert_eq!(
surface.discard_pending(),
Err(SurfaceError::Scene(SceneError::NoPendingFrame))
);
surface.require_snapshot().unwrap();
let recovery = present_and_accept(&mut surface, &mut renderer, 2);
assert_eq!(recovery.header.mode, FrameMode::Snapshot);
}
#[test]
fn projection_validation_and_error_sources_are_diagnostic() {
let mut scene = Scene::new(surface_id());
let live = scene.create_node(element_type()).unwrap();
let valid = LayoutRect {
width: 1.0,
height: 1.0,
..LayoutRect::default()
};
assert_eq!(
validate_layout_entries(&scene, &[(live, valid.into())]),
Ok(())
);
assert_eq!(
validate_layout_entries(&scene, &[(node_id(99), valid.into())]),
Err(SurfaceError::SceneLayoutMismatch { node: node_id(99) })
);
let invalid = LayoutRect {
width: f32::INFINITY,
..valid
};
assert_eq!(
validate_layout_entries(&scene, &[(live, invalid.into())]),
Err(SurfaceError::InvalidLayoutOutput { node: live })
);
let mut missing_layout = SurfaceEngine::new(surface_id());
let scene_only = missing_layout.scene.create_node(element_type()).unwrap();
assert_eq!(
missing_layout.set_measurement(scene_only, None),
Err(SurfaceError::Layout(LayoutError::UnknownNode(scene_only)))
);
assert_eq!(
missing_layout.invalidate_node(scene_only, PropertyImpactSet::TEXT_METRICS),
Err(SurfaceError::Layout(LayoutError::UnknownNode(scene_only)))
);
let mut missing_scene = SurfaceEngine::new(surface_id());
let layout_only = missing_scene
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
missing_scene.scene.delete_node(layout_only).unwrap();
assert_eq!(
missing_scene
.compute_layout(layout_only, LayoutSize::new(1.0, 1.0), &mut zero_measure,),
Err(SurfaceError::SceneLayoutMismatch { node: layout_only })
);
let mut missing_host_scene = SurfaceEngine::new(surface_id());
let host_layout_only = missing_host_scene
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
missing_host_scene
.scene
.delete_node(host_layout_only)
.unwrap();
assert_eq!(
missing_host_scene.compute_layout_with_measurements(
host_layout_only,
LayoutSize::new(1.0, 1.0),
1,
),
Err(SurfaceError::SceneLayoutMismatch {
node: host_layout_only
})
);
let mut invalid_host_layout = SurfaceEngine::new(surface_id());
let host_root = invalid_host_layout
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
assert_eq!(
invalid_host_layout.compute_layout_with_measurements(
host_root,
LayoutSize::new(f32::NAN, 1.0),
1,
),
Err(SurfaceError::Layout(LayoutError::InvalidViewport))
);
assert_eq!(
invalid_host_layout.compute_layout_with_measurements(
node_id(99),
LayoutSize::new(1.0, 1.0),
1,
),
Err(SurfaceError::Layout(LayoutError::UnknownNode(node_id(99))))
);
let scene_error = SurfaceError::from(SceneError::NoPendingFrame);
let layout_error = SurfaceError::from(LayoutError::InvalidViewport);
assert!(scene_error.source().is_some());
assert!(layout_error.source().is_some());
assert!(
SurfaceError::SceneLayoutMismatch { node: live }
.source()
.is_none()
);
assert!(
SurfaceError::InvalidLayoutOutput { node: live }
.source()
.is_none()
);
assert_eq!(
format!("{layout_error}"),
"Whisker surface error: Layout(InvalidViewport)"
);
}
#[test]
fn present_applies_acknowledgements_recovery_and_retry() {
enum SinkBehavior {
Record,
Fail,
WrongRevision,
NeedSnapshot,
}
struct TestSink {
behavior: SinkBehavior,
renderer: RecordingRenderer,
}
impl TestSink {
fn new(surface: SurfaceId) -> Self {
Self {
behavior: SinkBehavior::Record,
renderer: RecordingRenderer::new(surface),
}
}
}
impl FrameSink for TestSink {
type Error = &'static str;
fn capabilities(&self) -> whisker_protocol::RenderCapabilities {
self.renderer.capabilities()
}
fn present(&mut self, packet: &FramePacket) -> Result<ApplyResult, Self::Error> {
match self.behavior {
SinkBehavior::Record => self
.renderer
.present(packet)
.map_err(|_| "recording renderer rejected frame"),
SinkBehavior::Fail => Err("transport"),
SinkBehavior::WrongRevision => Ok(ApplyResult::Accepted {
revision: packet.header.target_revision + 1,
}),
SinkBehavior::NeedSnapshot => Ok(ApplyResult::NeedSnapshot {
receiver_revision: 0,
}),
}
}
}
let mut surface = SurfaceEngine::new(surface_id());
let root = surface
.create_node(element_type(), ComputedLayoutStyle::default())
.unwrap();
let mut sink = TestSink::new(surface_id());
assert_eq!(
sink.capabilities(),
whisker_protocol::RenderCapabilities::all_frame_native()
);
let already_prepared = surface.prepare_frame(1).unwrap().unwrap().clone();
assert_eq!(
surface.present(1, &mut sink),
Err(SurfacePresentError::Surface(SurfaceError::Scene(
SceneError::FramePending
)))
);
surface
.accept_pending(already_prepared.header.target_revision)
.unwrap();
assert_eq!(surface.present(1, &mut sink), Ok(None));
assert_eq!(surface.scene().accepted_revision(), 1);
surface
.scene
.set_visibility(root, whisker_protocol::Visibility::Hidden)
.unwrap();
sink.renderer = RecordingRenderer::new(surface_id());
assert_eq!(
surface.present(1, &mut sink),
Ok(Some(ApplyResult::NeedSnapshot {
receiver_revision: 0
}))
);
assert_eq!(surface.scene().accepted_revision(), 1);
assert_eq!(
surface.present(1, &mut sink),
Ok(Some(ApplyResult::Accepted { revision: 2 }))
);
assert_eq!(
sink.renderer.frames()[1].packet.header.mode,
FrameMode::Snapshot
);
surface.scene.set_z_order(root, 5).unwrap();
sink.behavior = SinkBehavior::Fail;
assert_eq!(
surface.present(1, &mut sink),
Err(SurfacePresentError::Sink("transport"))
);
assert!(surface.has_pending_work());
sink.behavior = SinkBehavior::Record;
assert_eq!(
surface.present(1, &mut sink),
Ok(Some(ApplyResult::Accepted { revision: 3 }))
);
assert_eq!(
sink.renderer.frames().last().unwrap().packet.header.mode,
FrameMode::Snapshot
);
assert_eq!(surface.present(1, &mut sink), Ok(None));
surface.scene.set_opacity(root, 0.4).unwrap();
sink.behavior = SinkBehavior::WrongRevision;
assert_eq!(
surface.present(1, &mut sink),
Err(SurfacePresentError::Surface(SurfaceError::Scene(
SceneError::AcceptedRevisionMismatch {
expected: 4,
received: 5,
}
)))
);
assert!(surface.has_pending_work());
sink.behavior = SinkBehavior::Record;
assert_eq!(
surface.present(1, &mut sink),
Ok(Some(ApplyResult::Accepted { revision: 4 }))
);
assert_eq!(
sink.renderer.frames().last().unwrap().packet.header.mode,
FrameMode::Snapshot
);
surface.scene.set_scene_epoch_for_tests(u32::MAX);
surface.scene.set_opacity(root, 0.6).unwrap();
sink.behavior = SinkBehavior::NeedSnapshot;
assert_eq!(
surface.present(1, &mut sink),
Err(SurfacePresentError::Surface(SurfaceError::Scene(
SceneError::SceneEpochExhausted
)))
);
let display = SurfacePresentError::<std::io::Error>::Surface(SurfaceError::Scene(
SceneError::NoPendingFrame,
));
assert!(display.source().is_some());
assert!(format!("{display}").starts_with("Whisker surface presentation error:"));
let sink = SurfacePresentError::Sink(std::io::Error::other("sink"));
assert!(sink.source().is_some());
}
}
#[cfg(test)]
#[path = "surface_paragraph_tests.rs"]
mod paragraph_tests;