use std::{collections::VecDeque, sync::Arc};
pub use super::delta::{Delta, Statistics};
use super::frame::{Frame, FrameToken};
use super::model::{Action, Artifact, CommitStatus, Error, Limits, PresentationLease, View};
use crate::canvas_protocol::SessionInvariant;
use crate::motion::node::critical::CriticalSpring;
mod query;
pub struct Canvas {
session: SessionInvariant,
lease: Option<PresentationLease>,
instance: Arc<()>,
generation: u64,
revision: u64,
limits: Limits,
artifact: Arc<Artifact>,
commit_status: CommitStatus,
optimistic_status: Option<CommitStatus>,
inbox: VecDeque<Action>,
motion: CriticalSpring,
target: View,
scroll: [usize; 3],
reduced: bool,
dirty: bool,
revoked: bool,
prepared: Option<FrameToken>,
presented: Option<FrameToken>,
serial: u64,
stats: Statistics,
}
impl Canvas {
pub fn new(
session: SessionInvariant,
generation: u64,
artifact: Artifact,
limits: Limits,
) -> Result<Self, Error> {
let lease = PresentationLease::new(
"diagnostic-lease",
"primary-surface",
session,
generation,
limits,
)?;
Self::with_lease(lease, artifact)
}
pub fn with_lease(lease: PresentationLease, artifact: Artifact) -> Result<Self, Error> {
lease.validate()?;
let limits = lease.limits();
let session = lease.session().clone();
let generation = lease.generation();
Error::require(
artifact.key() == session.work_object_id(),
Error::WrongScope,
)?;
Error::require(
artifact.payload_bytes() <= limits.text_bytes(),
Error::BudgetExceeded,
)?;
let commit_status = artifact.commit_status();
let motion = CriticalSpring::new(0.0, 0.45).map_err(Error::from)?;
Ok(Self {
session,
lease: Some(lease),
instance: Arc::new(()),
generation,
revision: 0,
limits,
artifact: Arc::new(artifact),
commit_status,
optimistic_status: None,
inbox: VecDeque::with_capacity(limits.queued_commands()),
motion,
target: View::Source,
scroll: [0; 3],
reduced: false,
dirty: true,
revoked: false,
prepared: None,
presented: None,
serial: 0,
stats: Statistics::default(),
})
}
pub fn deny_optimistic(&mut self) -> Result<(), Error> {
Error::require(!self.revoked, Error::Revoked)?;
let cancelled = self
.inbox
.iter()
.filter(|action| matches!(action, Action::OptimisticTransition(_)))
.count();
let cancelled_count = u64::try_from(cancelled)?;
let overlay_count = u64::from(self.optimistic_status.is_some());
let advance = cancelled_count
.checked_add(overlay_count)
.ok_or(Error::InvalidInput)?;
if advance > 0 {
let inbox_count = u64::try_from(self.inbox.len())?;
let live_count = inbox_count
.checked_sub(cancelled_count)
.ok_or(Error::InvalidInput)?;
let revision = self
.revision
.checked_add(advance)
.ok_or(Error::InvalidInput)?;
revision
.checked_add(live_count)
.ok_or(Error::InvalidInput)?;
self.inbox
.retain(|action| !matches!(action, Action::OptimisticTransition(_)));
self.optimistic_status = None;
self.revision = revision;
self.dirty = true;
self.presented = None;
self.prepared = None;
}
Ok(())
}
pub fn enqueue(&mut self, delta: Delta) -> Result<(), Error> {
Error::require(!self.revoked, Error::Revoked)?;
Error::require(delta.session == self.session, Error::WrongScope)?;
Error::require(
delta.generation == self.generation
&& delta.base_revision == self.next_base_revision()?,
Error::Stale,
)?;
Error::require(
self.inbox.len() != self.limits.queued_commands(),
Error::QueueFull,
)?;
delta
.base_revision
.checked_add(1)
.ok_or(Error::InvalidInput)?;
self.inbox.push_back(delta.action);
self.stats.accepted = self.stats.accepted.saturating_add(1);
Ok(())
}
pub fn input(&mut self, token: FrameToken, action: Action) -> Result<(), Error> {
Error::require(!self.revoked, Error::Revoked)?;
Error::require(self.presented.as_ref() == Some(&token), Error::Stale)?;
Error::require(
!matches!(
action,
Action::Transition(_) | Action::OptimisticTransition(_) | Action::RevertOptimistic
),
Error::WrongScope,
)?;
self.enqueue(Delta::new(
self.session.clone(),
self.generation,
self.next_base_revision()?,
action,
))
}
fn drain(&mut self) -> Result<(), Error> {
while let Some(action) = self.inbox.pop_front() {
match action {
Action::Navigate(view) => {
self.motion
.retarget(view_position(view))
.map_err(Error::from)?;
self.target = view;
}
Action::Step(amount) => {
let target = step_target(self.target, amount);
self.motion
.retarget(view_position(target))
.map_err(Error::from)?;
self.target = target;
}
Action::ToggleReducedMotion => self.reduced = !self.reduced,
Action::ReducedMotion(reduced) => self.reduced = reduced,
Action::Scroll { view, lines } => {
let max = self.artifact.text(view).lines().count().saturating_sub(1);
let max_line = i64::try_from(max)?;
let current = i64::try_from(self.scroll[view.index()])?;
let scrolled = current
.checked_add(i64::from(lines))
.ok_or(Error::InvalidInput)?;
let clamped = scrolled.clamp(0, max_line);
self.scroll[view.index()] = usize::try_from(clamped)?;
}
Action::Transition(status) => {
self.commit_status = status;
self.optimistic_status = None;
}
Action::OptimisticTransition(status) => {
self.optimistic_status = Some(status);
}
Action::RevertOptimistic => {
self.optimistic_status = None;
}
}
if self.reduced {
self.motion.snap();
}
self.revision = self.revision.checked_add(1).ok_or(Error::InvalidInput)?;
self.stats.drained = self.stats.drained.saturating_add(1);
self.dirty = true;
self.presented = None;
}
Ok(())
}
pub fn prepare(
&mut self,
seconds: f64,
width: u32,
height: u32,
force: bool,
) -> Result<Option<Frame>, Error> {
Error::require(!self.revoked, Error::Revoked)?;
Error::require(
seconds.is_finite() && (0.0..=60.0).contains(&seconds),
Error::InvalidInput,
)?;
self.limits.pixel_count(width, height)?;
if !force && !self.needs_frame() {
return Ok(None);
}
let serial = self.serial.checked_add(1).ok_or(Error::InvalidInput)?;
self.drain()?;
if !self.motion.is_settled() {
self.motion.advance(seconds).map_err(Error::from)?;
self.stats.sampled = self.stats.sampled.saturating_add(1);
}
if self.motion.is_settled() {
self.motion.snap();
}
self.serial = serial;
let token = FrameToken {
instance: Arc::clone(&self.instance),
generation: self.generation,
serial,
revision: self.revision,
};
self.prepared = Some(token.clone());
self.stats.prepared = self.stats.prepared.saturating_add(1);
let mut frame = Frame::new(
token,
Arc::clone(&self.artifact),
self.commit_status(),
self.commit_status,
self.is_optimistic(),
self.motion.velocity(),
self.motion.position(),
);
frame.set_target(self.target);
frame.set_scroll(self.scroll);
frame.set_viewport(width, height);
frame.set_reduced_motion(self.reduced);
frame.set_animating(!self.motion.is_settled());
Ok(Some(frame))
}
pub fn acknowledge_present(&mut self, token: FrameToken) -> Result<(), Error> {
Error::require(!self.revoked, Error::Revoked)?;
Error::require(
self.prepared.as_ref() == Some(&token) && token.revision == self.revision,
Error::Stale,
)?;
self.presented = Some(token);
self.prepared = None;
self.dirty = false;
self.stats.presented = self.stats.presented.saturating_add(1);
Ok(())
}
pub fn invalidate_surface(&mut self) {
self.presented = None;
self.prepared = None;
self.dirty = true;
}
pub fn resume_without_replay(&mut self) {
self.motion.snap();
self.invalidate_surface();
}
pub fn revoke(&mut self) {
self.revoked = true;
self.inbox.clear();
self.presented = None;
self.prepared = None;
}
}
fn view_position(view: View) -> f64 {
match view {
View::Source => 0.0,
View::Proposal => 1.0,
View::Evidence => 2.0,
}
}
fn step_target(current: View, amount: i32) -> View {
let base = match current {
View::Source => 0_i64,
View::Proposal => 1_i64,
View::Evidence => 2_i64,
};
let shifted = base.wrapping_add(i64::from(amount));
let reduced = shifted.wrapping_rem(3);
let index = if reduced < 0 {
reduced.wrapping_add(3)
} else {
reduced
};
match index {
0 => View::Source,
1 => View::Proposal,
_ => View::Evidence,
}
}
#[cfg(test)]
mod tests {
use super::{View, step_target};
fn assert_step(current: View, amount: i32, want: View) -> Result<(), String> {
let got = step_target(current, amount);
if got != want {
return Err(format!(
"step {current:?} by {amount}: got {got:?}, want {want:?}"
));
}
Ok(())
}
#[test]
fn step_target_wraps_like_euclidean_modulo_three() -> Result<(), String> {
assert_step(View::Source, 1, View::Proposal)?;
assert_step(View::Proposal, 1, View::Evidence)?;
assert_step(View::Evidence, 1, View::Source)?;
assert_step(View::Source, -1, View::Evidence)?;
assert_step(View::Evidence, -1, View::Proposal)?;
assert_step(View::Source, 3, View::Source)?;
assert_step(View::Source, -3, View::Source)?;
assert_step(View::Proposal, 4, View::Evidence)?;
assert_step(View::Evidence, -4, View::Proposal)?;
assert_step(View::Source, 0, View::Source)?;
assert_step(View::Source, i32::MAX, View::Proposal)?;
assert_step(View::Source, i32::MIN, View::Proposal)?;
assert_step(View::Evidence, i32::MAX, View::Source)?;
Ok(())
}
}