Unify scrolling viewport presentation ownership

compositor/src/state/viewport.rs

@@ -0,0 +1,428 @@
+use super::*;
+
+#[derive(Clone, PartialEq)]
+enum ViewportOwner {
+    Spring,
+    Gesture(Box<FocusSwipe>),
+}
+
+#[derive(Clone, PartialEq)]
+enum ViewportMode {
+    Running(ViewportOwner),
+    // The paused owner keeps its position and velocity. Releasing consumes one
+    // tick before that same owner resumes, excluding time spent waiting.
+    Held(ViewportOwner),
+    // The release frame excludes held wall time and presents zero velocity.
+    Resuming(ViewportOwner),
+}
+
+#[derive(Clone, PartialEq)]
+pub(super) struct ViewportPresentation {
+    motion: AnimatedValue,
+    mode: ViewportMode,
+}
+
+impl ViewportPresentation {
+    pub(super) fn new(target: f64) -> Self {
+        Self {
+            motion: AnimatedValue::new(target),
+            mode: ViewportMode::Running(ViewportOwner::Spring),
+        }
+    }
+
+    #[cfg(test)]
+    pub(super) fn from_motion(motion: AnimatedValue) -> Self {
+        Self {
+            motion,
+            ..Self::new(motion.target)
+        }
+    }
+
+    pub(super) fn motion(&self) -> &AnimatedValue {
+        &self.motion
+    }
+
+    pub(super) fn retarget(&mut self, target: f64, animations: bool) -> bool {
+        let changed = (self.motion.target - target).abs() > 0.001;
+        self.motion.retarget_preserving_motion(target);
+        if !animations {
+            self.motion.snap();
+        }
+        changed
+    }
+
+    pub(super) fn gesture(&self) -> Option<&FocusSwipe> {
+        match &self.mode {
+            ViewportMode::Running(ViewportOwner::Gesture(swipe))
+            | ViewportMode::Held(ViewportOwner::Gesture(swipe))
+            | ViewportMode::Resuming(ViewportOwner::Gesture(swipe)) => Some(swipe),
+            _ => None,
+        }
+    }
+
+    pub(super) fn update_gesture(&mut self, progress: f64) {
+        match &mut self.mode {
+            ViewportMode::Running(ViewportOwner::Gesture(swipe))
+            | ViewportMode::Held(ViewportOwner::Gesture(swipe))
+            | ViewportMode::Resuming(ViewportOwner::Gesture(swipe)) => swipe.progress = progress,
+            _ => {}
+        }
+    }
+
+    pub(super) fn begin_gesture(&mut self, swipe: FocusSwipe) {
+        debug_assert!(self.gesture().is_none());
+        let owner = ViewportOwner::Gesture(Box::new(swipe));
+        self.mode = if self.is_held() {
+            ViewportMode::Held(owner)
+        } else {
+            ViewportMode::Running(owner)
+        };
+    }
+
+    pub(super) fn end_gesture(&mut self, release_velocity: Option<f64>) -> Option<FocusSwipe> {
+        self.gesture()?;
+        let mode = std::mem::replace(&mut self.mode, ViewportMode::Running(ViewportOwner::Spring));
+        let (swipe, held) = match mode {
+            ViewportMode::Running(ViewportOwner::Gesture(swipe)) => (swipe, false),
+            ViewportMode::Held(ViewportOwner::Gesture(swipe)) => (swipe, true),
+            ViewportMode::Resuming(ViewportOwner::Gesture(swipe)) => (swipe, false),
+            _ => unreachable!(),
+        };
+        if let Some(velocity) = release_velocity {
+            self.motion.current = swipe.position();
+            self.motion.velocity = velocity;
+        }
+        if held {
+            self.mode = ViewportMode::Held(ViewportOwner::Spring);
+        }
+        Some(*swipe)
+    }
+
+    pub(super) fn is_held(&self) -> bool {
+        matches!(self.mode, ViewportMode::Held(_))
+    }
+
+    // Commits/deadlines retain a release tick. An independent retarget can
+    // discard the old dependency hold immediately instead.
+    pub(super) fn reconcile_hold(&mut self, blocked: bool, release_tick: bool) {
+        let mode = std::mem::replace(&mut self.mode, ViewportMode::Running(ViewportOwner::Spring));
+        self.mode = match mode {
+            ViewportMode::Running(owner) | ViewportMode::Resuming(owner) if blocked => ViewportMode::Held(owner),
+            ViewportMode::Held(owner) if !blocked && !release_tick => ViewportMode::Running(owner),
+            mode => mode,
+        };
+    }
+
+    pub(super) fn presented_motion(&self) -> AnimatedValue {
+        let mut motion = self.motion;
+        if matches!(self.mode, ViewportMode::Held(_) | ViewportMode::Resuming(_)) {
+            motion.velocity = 0.0;
+        }
+        motion
+    }
+
+    pub(super) fn needs_tick(&self) -> bool {
+        self.is_held()
+            || self.gesture().is_some()
+            || self.motion.current != self.motion.target
+            || self.motion.velocity != 0.0
+    }
+
+    #[cfg(feature = "resize-metrics")]
+    pub(super) fn spring_is_moving(&self) -> bool {
+        self.gesture().is_none() && (self.motion.current != self.motion.target || self.motion.velocity != 0.0)
+    }
+
+    // Prediction and authoritative ticks evaluate the same motion step. The
+    // sampler borrows gesture/dependency metadata instead of cloning layouts.
+    fn step_motion(
+        &self,
+        delta: Duration,
+        spring: SpringConfig,
+        animations: bool,
+        blocked: bool,
+    ) -> (AnimatedValue, bool) {
+        let mut motion = self.motion;
+        if blocked || self.is_held() {
+            return (motion, blocked || self.needs_tick());
+        }
+        let active = match &self.mode {
+            ViewportMode::Running(ViewportOwner::Gesture(swipe))
+            | ViewportMode::Resuming(ViewportOwner::Gesture(swipe)) => {
+                motion.current = swipe.position();
+                motion.velocity = 0.0;
+                true
+            }
+            ViewportMode::Running(ViewportOwner::Spring) | ViewportMode::Resuming(ViewportOwner::Spring)
+                if animations =>
+            {
+                motion.advance(delta, spring)
+            }
+            ViewportMode::Running(ViewportOwner::Spring) | ViewportMode::Resuming(ViewportOwner::Spring) => {
+                motion.snap();
+                false
+            }
+            ViewportMode::Held(_) => unreachable!(),
+        };
+        (motion, active)
+    }
+
+    pub(super) fn advance(&mut self, delta: Duration, spring: SpringConfig, animations: bool, blocked: bool) -> bool {
+        let (motion, active) = self.step_motion(delta, spring, animations, blocked);
+        self.motion = motion;
+        let mode = std::mem::replace(&mut self.mode, ViewportMode::Running(ViewportOwner::Spring));
+        self.mode = match mode {
+            ViewportMode::Running(owner) | ViewportMode::Held(owner) | ViewportMode::Resuming(owner) if blocked => {
+                ViewportMode::Held(owner)
+            }
+            ViewportMode::Held(owner) => ViewportMode::Resuming(owner),
+            ViewportMode::Running(owner) | ViewportMode::Resuming(owner) => ViewportMode::Running(owner),
+        };
+        active
+    }
+
+    pub(super) fn sample(
+        &self,
+        delta: Duration,
+        spring: SpringConfig,
+        animations: bool,
+        blocked: bool,
+    ) -> AnimatedValue {
+        let (mut motion, _) = self.step_motion(delta, spring, animations, blocked);
+        if blocked || self.is_held() {
+            motion.velocity = 0.0;
+        }
+        motion
+    }
+}
+
+impl Ferese {
+    pub(super) fn focus_swipe(&self) -> Option<&FocusSwipe> {
+        self.viewports.values().find_map(ViewportPresentation::gesture)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const TICK: Duration = Duration::from_millis(16);
+
+    fn moving() -> ViewportPresentation {
+        let mut viewport = ViewportPresentation::new(0.0);
+        viewport.retarget(500.0, true);
+        viewport.advance(TICK, SpringConfig::default(), true, false);
+        viewport
+    }
+
+    fn swipe(viewport: &ViewportPresentation) -> FocusSwipe {
+        FocusSwipe {
+            workspace: WorkspaceId(1),
+            from: WindowId(1),
+            to: WindowId(2),
+            direction: Direction::Right,
+            gesture_direction: SwipeDirection::Left,
+            start: viewport.motion.current,
+            destination: 700.0,
+            progress: 0.0,
+            layout: None,
+            dependencies: None,
+        }
+    }
+
+    #[test]
+    fn focus_retarget_preserves_moving_spring_position_and_velocity() {
+        let mut viewport = moving();
+        let before = viewport.motion;
+        viewport.retarget(-200.0, true);
+        assert_eq!(viewport.motion.current, before.current);
+        assert_eq!(viewport.motion.velocity, before.velocity);
+        assert_eq!(viewport.motion.target, -200.0);
+        let mut expected = before;
+        expected.retarget_preserving_motion(-200.0);
+        expected.advance(TICK, SpringConfig::default());
+        viewport.advance(TICK, SpringConfig::default(), true, false);
+        assert_eq!(viewport.motion, expected);
+    }
+
+    #[test]
+    fn gesture_interrupts_spring_and_releases_from_latest_input() {
+        let mut viewport = moving();
+        let before = viewport.motion.current;
+        viewport.begin_gesture(swipe(&viewport));
+        viewport.advance(Duration::from_secs(5), SpringConfig::default(), true, false);
+        assert_eq!(viewport.motion.current, before);
+        assert_eq!(viewport.motion.velocity, 0.0);
+        viewport.update_gesture(0.5);
+        // No frame is necessary between the last input and release.
+        let position = viewport.gesture().unwrap().position();
+        let velocity = viewport.gesture().unwrap().release_velocity(0.4, 99.0);
+        viewport.end_gesture(Some(velocity)).unwrap();
+        viewport.retarget(700.0, true);
+        assert_eq!(viewport.motion.current, position);
+        assert_eq!(viewport.motion.velocity, velocity);
+        assert!(matches!(viewport.mode, ViewportMode::Running(ViewportOwner::Spring)));
+        let mut expected = viewport.motion;
+        expected.advance(TICK, SpringConfig::default());
+        viewport.advance(TICK, SpringConfig::default(), true, false);
+        assert_eq!(viewport.motion, expected);
+    }
+
+    #[test]
+    fn edge_gesture_keeps_rubber_band_and_release_derivative() {
+        let mut viewport = moving();
+        let mut gesture = swipe(&viewport);
+        gesture.to = gesture.from;
+        gesture.destination = gesture.start;
+        gesture.progress = 2.0;
+        let (position, derivative) = ferese_animation::gesture::rubber_band(2.0, 1.0, 0.55);
+        let expected = gesture.start + 64.0 * position;
+        assert_eq!(gesture.release_velocity(99.0, 0.4), 64.0 * 0.4 * derivative);
+        viewport.begin_gesture(gesture);
+        viewport.advance(TICK, SpringConfig::default(), true, false);
+        assert_eq!(viewport.motion.current, expected);
+    }
+
+    #[test]
+    fn hold_release_retains_motion_and_excludes_waiting_wall_time() {
+        let mut viewport = moving();
+        let frozen = viewport.motion;
+        viewport.reconcile_hold(true, false);
+        viewport.advance(Duration::from_secs(3), SpringConfig::default(), true, true);
+        assert_eq!(viewport.motion, frozen);
+        assert_eq!(viewport.presented_motion().velocity, 0.0);
+        viewport.reconcile_hold(false, true);
+        viewport.advance(Duration::from_secs(2), SpringConfig::default(), true, false);
+        assert_eq!(viewport.motion, frozen);
+        assert_eq!(viewport.presented_motion().velocity, 0.0);
+        let mut expected = frozen;
+        expected.advance(TICK, SpringConfig::default());
+        viewport.advance(TICK, SpringConfig::default(), true, false);
+        assert_eq!(viewport.motion, expected);
+        assert_eq!(viewport.presented_motion(), expected);
+    }
+
+    #[test]
+    fn held_retarget_preserves_motion_until_its_dependencies_clear() {
+        let mut viewport = moving();
+        viewport.reconcile_hold(true, false);
+        let frozen = viewport.motion;
+        viewport.retarget(900.0, true);
+        viewport.reconcile_hold(true, false);
+        viewport.advance(TICK, SpringConfig::default(), true, true);
+        assert_eq!(viewport.motion.current, frozen.current);
+        assert_eq!(viewport.motion.velocity, frozen.velocity);
+        assert_eq!(viewport.motion.target, 900.0);
+        // An independent policy request retires the hold immediately, even if
+        // other widths on this workspace are still awaiting client commits.
+        viewport.retarget(-100.0, true);
+        viewport.reconcile_hold(false, false);
+        assert!(!viewport.is_held());
+        viewport.advance(TICK, SpringConfig::default(), true, false);
+        assert_ne!(viewport.motion.current, frozen.current);
+    }
+
+    #[test]
+    fn hold_pauses_gesture_owner_and_release_resumes_that_gesture() {
+        let mut viewport = moving();
+        let frozen = viewport.motion;
+        viewport.reconcile_hold(true, false);
+        viewport.begin_gesture(swipe(&viewport));
+        viewport.update_gesture(0.75);
+        let position = viewport.gesture().unwrap().position();
+        viewport.advance(TICK, SpringConfig::default(), true, true);
+        assert_eq!(viewport.motion, frozen);
+        viewport.advance(Duration::from_secs(3), SpringConfig::default(), true, false);
+        assert_eq!(viewport.motion, frozen);
+        viewport.advance(TICK, SpringConfig::default(), true, false);
+        assert_eq!(viewport.motion.current, position);
+        assert_eq!(viewport.motion.velocity, 0.0);
+        assert!(viewport.gesture().is_some());
+    }
+
+    #[test]
+    fn blocked_gesture_release_does_not_publish_uncommitted_position() {
+        let mut viewport = moving();
+        let frozen = viewport.motion;
+        viewport.begin_gesture(swipe(&viewport));
+        viewport.update_gesture(0.8);
+        viewport.reconcile_hold(true, false);
+        viewport.end_gesture(None).unwrap();
+        viewport.retarget(700.0, true);
+        assert!(matches!(viewport.mode, ViewportMode::Held(ViewportOwner::Spring)));
+        assert_eq!(viewport.motion.current, frozen.current);
+        assert_eq!(viewport.motion.velocity, frozen.velocity);
+    }
+
+    #[test]
+    fn prediction_steps_a_copy_of_every_owner_and_hold_phase() {
+        let running = moving();
+        let mut gesture = running.clone();
+        gesture.begin_gesture(swipe(&gesture));
+        gesture.update_gesture(0.3);
+        let mut held_spring = running.clone();
+        held_spring.reconcile_hold(true, false);
+        let mut held_gesture = gesture.clone();
+        held_gesture.reconcile_hold(true, false);
+        let mut resuming = held_spring.clone();
+        resuming.advance(TICK, SpringConfig::default(), true, false);
+        for state in [running, gesture, held_spring, held_gesture, resuming] {
+            for blocked in [false, true] {
+                for horizon in [Duration::ZERO, TICK, Duration::from_millis(40)] {
+                    let original = state.clone();
+                    let sample = state.sample(horizon, SpringConfig::default(), true, blocked);
+                    let mut advanced = state.clone();
+                    advanced.advance(horizon, SpringConfig::default(), true, blocked);
+                    assert_eq!(sample, advanced.presented_motion());
+                    assert!(state == original, "prediction changed authoritative mode or motion");
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn layout_handoff_preserves_screen_position_for_each_viewport_owner() {
+        let spring = moving();
+        let mut gesture = spring.clone();
+        gesture.begin_gesture(swipe(&gesture));
+        gesture.update_gesture(0.6);
+        gesture.advance(TICK, SpringConfig::default(), true, false);
+        let mut held = spring.clone();
+        held.reconcile_hold(true, false);
+        for viewport in [spring, gesture, held] {
+            let mut geometry = WindowGeometry::new(Rect::new(123.0, 0.0, 400.0, 300.0), None);
+            geometry.visual.velocity.x = 42.0;
+            let before = geometry.visual;
+            let motion = viewport.presented_motion();
+            let mut world = AnimatedValue::new(restored_scrolling_world_x(
+                true,
+                before.current.x,
+                motion.current,
+                900.0,
+            ));
+            world.velocity = before.velocity.x + motion.velocity;
+            world.set_target(geometry.logical.x + motion.target);
+            super::super::animation::sync_scrolling_coordinates(&mut geometry, &mut world, &motion, false);
+            assert!((geometry.visual.current.x - before.current.x).abs() < 1e-6);
+            assert!((geometry.visual.velocity.x - before.velocity.x).abs() < 1e-6);
+            assert_eq!(geometry.logical.x, world.target - motion.target);
+        }
+    }
+
+    #[test]
+    fn reduced_motion_snaps_policy_target_after_hold_release() {
+        let mut viewport = moving();
+        viewport.reconcile_hold(true, false);
+        let frozen = viewport.motion;
+        viewport.advance(TICK, SpringConfig::default(), false, true);
+        assert_eq!(viewport.motion, frozen);
+        viewport.advance(TICK, SpringConfig::default(), false, false);
+        assert_eq!(viewport.motion, frozen);
+        viewport.advance(TICK, SpringConfig::default(), false, false);
+        assert_eq!(viewport.motion.current, viewport.motion.target);
+        assert_eq!(viewport.motion.velocity, 0.0);
+        assert!(!viewport.needs_tick());
+        viewport.retarget(300.0, false);
+        assert_eq!(viewport.motion.current, 300.0);
+    }
+}