Integrate persistent canvas controls with scenario lifetime rendering

2026-09-11 12:44:06 -07:00
parent 32334c6631
commit a57c334b30
42 changed files with 11751 additions and 2163 deletions
@@ -4,7 +4,9 @@ use super::topology::{occurrence, unique_batch};
 use super::*;
 use iced::widget::{Column, column, text_input};
 use std::{cell::RefCell, collections::BTreeSet};
+pub(crate) mod focus;
 mod workspace;
+pub(crate) use workspace::NAME_INPUT;
 pub use workspace::{Shelf, view};

 #[cfg(test)]
@@ -94,11 +96,12 @@ impl std::fmt::Display for CanvasTool {
 }
 #[derive(Debug, Clone)]
 pub enum CanvasEvent {
-    First(Context, Tool),
    Scrolled(Context, ScrollArea, iced::Vector),
    Restored(Context, Id, ScrollArea, iced::Vector),
    Viewport(Context, Size),
+    FormShown(Context, Id),
    Zoom(Context, Option<f32>),
+    Camera(Context, u64, super::canvas_workspace::Event),
    Focus(Context),
    Shelf(Context, Shelf),
    OpenUse(Context, Id),
@@ -126,18 +129,18 @@ pub enum CanvasEvent {
 }
 #[derive(Debug, Clone, Copy)]
 pub enum ScrollArea {
-    Canvas,
-    // Retained navigation channel, now the independent Selection/outline shelf.
+    // The independent Details/outline scroller; viewport motion uses Camera.
    Page,
 }
 impl CanvasEvent {
    pub fn context(&self) -> Context {
        match self {
-            Self::First(context, _)
-            | Self::Scrolled(context, _, _)
+            Self::Scrolled(context, _, _)
            | Self::Restored(context, ..)
            | Self::Viewport(context, _)
+            | Self::FormShown(context, _)
            | Self::Zoom(context, _)
+            | Self::Camera(context, ..)
            | Self::Focus(context)
            | Self::Shelf(context, _)
            | Self::OpenUse(context, _)
@@ -200,11 +203,14 @@ const VALUE_PAGE_SIZE: usize = 24;
 #[derive(Default)]
 pub struct State {
    draft: Option<Draft>,
+    form_session: Id,
+    form_mount: Id,
+    form_focus_pending: bool,
    canvas_tool: Option<(Id, CanvasTool)>,
    call_choices: RefCell<Option<(CallChoiceContext, Vec<Choice>)>>,
-    scroll_offsets: [iced::Vector; 2],
+    details_offset: iced::Vector,
    return_to: Vec<Caller>,
-    restore: Option<ViewportRestore>,
+    restore: Option<DetailsRestore>,
    presentation: workspace::Presentation,
 }
 const CALLER_LIMIT: usize = 32;
@@ -214,15 +220,14 @@ pub(crate) struct Caller {
    pub occurrence: Id,
    target: Id,
    tool: CanvasTool,
-    offsets: [iced::Vector; 2],
+    details_offset: iced::Vector,
    presentation: workspace::Presentation,
 }
-struct ViewportRestore {
+struct DetailsRestore {
    document: Id,
    owner: Id,
    token: Id,
-    offsets: [iced::Vector; 2],
-    pending: [bool; 2],
+    offset: iced::Vector,
 }
 #[derive(Clone, Copy)]
 pub(super) struct ScrollRestore {
@@ -282,6 +287,18 @@ struct Draft {
    choice_page: usize,
 }
 impl State {
+    pub(crate) fn camera_boundary(&self) -> impl PartialEq + use<> {
+        (
+            self.canvas_tool,
+            self.presentation.focused,
+            self.presentation.shelf,
+            self.presentation.viewport,
+            self.presentation.pan,
+            self.presentation.zoom,
+            self.presentation.fit,
+        )
+    }
+
    pub(super) fn pending_name(&self) -> Option<&str> {
        self.draft.as_ref().map(|d| d.name.as_str())
    }
@@ -301,7 +318,11 @@ impl State {
        self.draft.as_ref().is_some_and(|d| d.source.is_open())
    }
    pub fn source_back(&mut self) -> bool {
-        self.draft.as_mut().is_some_and(|d| d.source.back())
+        let returned = self.draft.as_mut().is_some_and(|d| d.source.back());
+        if returned {
+            self.remount_form();
+        }
+        returned
    }

    pub(crate) fn enter(&mut self, document: Id, owner: Id) {
@@ -311,16 +332,38 @@ impl State {
                focused: self.presentation.focused,
                ..Default::default()
            };
-            self.scroll_offsets = [iced::Vector::ZERO; 2];
+            self.details_offset = iced::Vector::ZERO;
            self.restore = None;
        }
    }
    pub(crate) fn viewport(&mut self, size: Size) -> bool {
        self.presentation.viewport(size)
    }
+    pub(crate) fn camera(&mut self, event: super::canvas_workspace::Event) -> bool {
+        let p = &mut self.presentation;
+        super::canvas_workspace::change(&mut p.pan, &mut p.zoom, &mut p.fit, event)
+    }
    pub(crate) fn zoom(&mut self, scale: Option<f32>) -> bool {
        self.presentation.zoom(scale)
    }
+    pub(crate) fn camera_zoom(&mut self, p: &Project, owner: Id, zoom: Option<f32>) -> bool {
+        let size = Scene::sequence(p, owner, owner).size;
+        let old = self.presentation.scale(size);
+        if let Some(next) = zoom {
+            let viewport = self.presentation.viewport.unwrap_or(Size::new(500., 300.));
+            self.camera(super::canvas_workspace::Event::Zoom {
+                factor: next / old,
+                at: Point::new(viewport.width / 2., viewport.height / 2.),
+                base: old,
+            })
+        } else {
+            self.zoom(None);
+            let fitted = self.presentation.scale(size);
+            self.zoom(Some(fitted));
+            self.presentation.pan = iced::Vector::ZERO;
+            true
+        }
+    }
    pub(crate) fn focused(&self) -> bool {
        self.presentation.focused
    }
@@ -349,11 +392,11 @@ impl State {
            occurrence,
            target,
            tool: self.canvas_tool(context.scenario),
-            offsets: self.scroll_offsets,
+            details_offset: self.details_offset,
            presentation: self.presentation.clone(),
        });
        self.canvas_tool = Some((target, CanvasTool::Select));
-        self.scroll_offsets = [iced::Vector::ZERO; 2];
+        self.details_offset = iced::Vector::ZERO;
        self.restore = None;
        Ok(target)
    }
@@ -380,34 +423,30 @@ impl State {
            return;
        }
        self.canvas_tool = Some((frame.owner, frame.tool));
-        self.scroll_offsets = frame.offsets;
+        self.details_offset = frame.details_offset;
        self.presentation = frame.presentation;
        self.presentation.identity = Some((context.document, context.scenario));
-        self.restore = Some(ViewportRestore {
+        self.restore = Some(DetailsRestore {
            document: context.document,
            owner: frame.owner,
            token: Id::new_v4(),
-            offsets: frame.offsets,
-            pending: [true; 2],
+            offset: frame.details_offset,
        });
    }
    pub(super) fn scroll_restore(
        &self,
        context: Context,
-        area: ScrollArea,
+        ScrollArea::Page: ScrollArea,
    ) -> Option<ScrollRestore> {
-        let index = match area {
-            ScrollArea::Canvas => 0,
-            ScrollArea::Page => 1,
-        };
-        let restore = self.restore.as_ref().filter(|r| {
-            r.document == context.document && r.owner == context.scenario && r.pending[index]
-        })?;
+        let restore = self
+            .restore
+            .as_ref()
+            .filter(|r| r.document == context.document && r.owner == context.scenario)?;
        Some(ScrollRestore {
            document: restore.document,
            owner: restore.owner,
            token: restore.token,
-            offset: restore.offsets[index],
+            offset: restore.offset,
        })
    }
    pub(crate) fn restored(
@@ -417,22 +456,12 @@ impl State {
        area: ScrollArea,
        offset: iced::Vector,
    ) -> bool {
-        let index = match area {
-            ScrollArea::Canvas => 0,
-            ScrollArea::Page => 1,
-        };
-        let Some(restore) = self.restore.as_mut().filter(|r| {
-            r.document == context.document
-                && r.owner == context.scenario
-                && r.token == token
-                && r.pending[index]
-        }) else {
+        if !self.restore.as_ref().is_some_and(|r| {
+            r.document == context.document && r.owner == context.scenario && r.token == token
+        }) {
            return false;
-        };
-        restore.pending[index] = false;
-        if !restore.pending.contains(&true) {
-            self.restore = None;
        }
+        self.restore = None;
        self.scrolled(area, offset)
    }
    pub(super) fn recovery_snapshot(&self) -> Result<Option<serde_json::Value>, String> {
@@ -445,28 +474,57 @@ impl State {

    pub(super) fn from_recovery(value: serde_json::Value) -> Result<Self, String> {
        let draft = serde_json::from_value(value).map_err(|e| e.to_string())?;
+        let session = Id::new_v4();
        Ok(Self {
            draft: Some(draft),
+            form_session: session,
+            form_mount: session,
+            form_focus_pending: true,
            ..Default::default()
        })
    }

-    pub(crate) fn scrolled(&mut self, area: ScrollArea, offset: iced::Vector) -> bool {
+    pub(crate) fn form_session(&self) -> Option<Id> {
+        self.draft.as_ref().map(|_| self.form_session)
+    }
+
+    pub(crate) fn form_mount(&self) -> Option<Id> {
+        self.draft
+            .as_ref()
+            .filter(|d| !d.source.is_open())
+            .map(|_| self.form_mount)
+    }
+
+    pub(crate) fn focus_stamp(&self, context: Context) -> Option<focus::Stamp> {
+        (self.draft.as_ref()?.owner == context.scenario).then_some(focus::Stamp::new(
+            context,
+            self.form_session,
+            self.form_mount()?,
+        ))
+    }
+
+    fn remount_form(&mut self) {
+        self.form_mount = Id::new_v4();
+        self.form_focus_pending = true;
+    }
+
+    pub(crate) fn take_form_focus(&mut self, mount: Id) -> bool {
+        if self.form_mount() == Some(mount) && self.form_focus_pending {
+            self.form_focus_pending = false;
+            true
+        } else {
+            false
+        }
+    }
+
+    pub(crate) fn scrolled(&mut self, ScrollArea::Page: ScrollArea, offset: iced::Vector) -> bool {
        if !offset.x.is_finite() || !offset.y.is_finite() || offset.x < 0. || offset.y < 0. {
            return false;
        }
-        let index = match area {
-            ScrollArea::Canvas => 0,
-            ScrollArea::Page => 1,
-        };
-        let changed = self.scroll_offsets[index] != offset;
-        self.scroll_offsets[index] = offset;
+        let changed = self.details_offset != offset;
+        self.details_offset = offset;
        changed
    }
-    fn scroll_offset(&self) -> iced::Vector {
-        // The former page scroll now belongs to a sibling outline shelf.
-        self.scroll_offsets[0]
-    }
    fn call_choices(&self, p: &Project, context: Context, draft: &Draft) -> Vec<Choice> {
        let key = CallChoiceContext {
            document: context.document,
@@ -616,6 +674,7 @@ impl State {
                .source
                .dismiss(&event)?
            {
+                self.remount_form();
                return Ok(None);
            }
            let d = self
@@ -656,7 +715,11 @@ impl State {
                next.target = Some(id);
                next.command(p)?;
            }
+            let returned = d.source.is_open() && !next.source.is_open();
            self.draft = Some(next);
+            if returned {
+                self.remount_form();
+            }
            return Ok(None);
        }
        if self.source_open() && !matches!(&event, Event::Cancel) {
@@ -671,6 +734,9 @@ impl State {
                if p.elements.get(&owner).map(oa_core::Element::kind) != Some(Kind::Scenario) {
                    return Err("Choose a scenario.".into());
                }
+                self.form_session = Id::new_v4();
+                self.form_mount = self.form_session;
+                self.form_focus_pending = true;
                self.draft = Some(Draft {
                    source: Default::default(),
                    invocation: Id::new_v4(),
@@ -1986,20 +2052,31 @@ pub(crate) mod direct_tests {
            navigation_event(&mut app, |ctx| {
                CanvasEvent::Choose(ctx, CanvasTool::Add(Tool::Reuse))
            });
+            navigation_event(&mut app, |ctx| CanvasEvent::Zoom(ctx, None));
+            let camera_epoch = app.camera_epoch;
            navigation_event(&mut app, |ctx| {
-                CanvasEvent::Scrolled(ctx, ScrollArea::Canvas, iced::Vector::new(25., 170.))
+                CanvasEvent::Camera(
+                    ctx,
+                    camera_epoch,
+                    super::super::canvas_workspace::Event::Pan(iced::Vector::new(25., 170.)),
+                )
            });
            navigation_event(&mut app, |ctx| {
                CanvasEvent::Scrolled(ctx, ScrollArea::Page, iced::Vector::new(0., 80.))
            });
            navigation_event(&mut app, |ctx| CanvasEvent::OpenUse(ctx, caller));
            assert_eq!(app.selected, b);
-            assert_eq!(app.behavior.scenario.scroll_offset(), iced::Vector::ZERO);
+            assert_eq!(app.behavior.scenario.presentation.pan, iced::Vector::ZERO);
            navigation_event(&mut app, |ctx| {
                CanvasEvent::Choose(ctx, CanvasTool::Message(MessageStyle::Timer))
            });
+            let camera_epoch = app.camera_epoch;
            navigation_event(&mut app, |ctx| {
-                CanvasEvent::Scrolled(ctx, ScrollArea::Canvas, iced::Vector::new(0., 115.))
+                CanvasEvent::Camera(
+                    ctx,
+                    camera_epoch,
+                    super::super::canvas_workspace::Event::Pan(iced::Vector::new(0., 115.)),
+                )
            });
            navigation_event(&mut app, |ctx| CanvasEvent::OpenUse(ctx, nested));
            assert_eq!(app.selected, c);
@@ -2010,7 +2087,7 @@ pub(crate) mod direct_tests {
                CanvasTool::Message(MessageStyle::Timer)
            );
            assert_eq!(
-                app.behavior.scenario.scroll_offset(),
+                app.behavior.scenario.presentation.pan,
                iced::Vector::new(0., 115.)
            );
            navigation_event(&mut app, CanvasEvent::Back);
@@ -2021,11 +2098,11 @@ pub(crate) mod direct_tests {
                CanvasTool::Add(Tool::Reuse)
            );
            assert_eq!(
-                app.behavior.scenario.scroll_offset(),
+                app.behavior.scenario.presentation.pan,
                iced::Vector::new(25., 170.)
            );
            assert_eq!(
-                app.behavior.scenario.scroll_offsets[1],
+                app.behavior.scenario.details_offset,
                iced::Vector::new(0., 80.),
                "The caller's independent outline scroll is restored separately"
            );
@@ -2203,22 +2280,24 @@ pub(crate) mod direct_tests {
                    let before = app.document.bundle().clone();
                    let mut scene = Scene::sequence(app.project(), f.owner, f.call);
                    scene.interaction = Some((context, CanvasTool::Add(tool), true));
-                    scene.scroll_offset = iced::Vector::new(23., 80.);
-                    let bounds = Rectangle::new(Point::new(20., 40.), scene.size);
+                    scene.camera_pan = iced::Vector::new(23., 80.);
+                    let bounds = Rectangle::new(
+                        Point::new(20., 40.),
+                        Size::new(scene.size.width + 46., scene.size.height + 160.),
+                    );
                    let y = scene.slots.iter().find(|s| s.slot == slot).unwrap().y;
                    let x = if on_lifeline {
                        scene.lanes[&f.sender]
                    } else {
                        scene.size.width - 35.
                    };
-                    let point = Point::new(bounds.x + x, bounds.y + y);
+                    let point = Point::new(bounds.x + x, bounds.y + y) + scene.camera_pan;
+                    assert!(bounds.contains(point));
                    let mut input = SequenceInput::default();
                    canvas_mouse(
                        &scene,
                        &mut input,
-                        mouse::Event::CursorMoved {
-                            position: point - scene.scroll_offset,
-                        },
+                        mouse::Event::CursorMoved { position: point },
                        point,
                        bounds,
                    );
@@ -2394,10 +2473,10 @@ pub(crate) mod direct_tests {
            assert!(!app.behavior.has_pending());
        }
        let old_context = app.scenario_context().unwrap();
-        let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Scrolled(
+        let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Camera(
            old_context,
-            ScrollArea::Canvas,
-            iced::Vector::new(0., 100.),
+            app.camera_epoch,
+            super::super::canvas_workspace::Event::Pan(iced::Vector::new(0., 100.)),
        )));
        let _ = app.update(Message::ScenarioCanvas(event(old_context)));
        assert!(!app.behavior.has_pending());
@@ -2588,26 +2667,29 @@ pub(crate) mod direct_tests {
        );
    }
    #[test]
-    fn direct_busy_save_keeps_observed_scroll_current_for_the_next_pointer_gesture() {
+    fn direct_busy_save_keeps_details_current_and_camera_for_the_next_pointer_gesture() {
        let f = fixture();
        let mut app = App::with_project(f.project.clone());
        let _ = app.update(Message::Select(f.owner));
        let _ = app.update(Message::Page(crate::app::Page::Behavior));
        let context = app.scenario_context().unwrap();
+        let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Camera(
+            context,
+            app.camera_epoch,
+            super::super::canvas_workspace::Event::Pan(iced::Vector::new(-25., -100.)),
+        )));
+        let context = app.scenario_context().unwrap();
        let original = app.document.snapshot();
        app.busy = true;
-        for (area, offset) in [
-            (ScrollArea::Canvas, iced::Vector::new(25., 100.)),
-            (ScrollArea::Page, iced::Vector::new(0., 40.)),
-        ] {
-            let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Scrolled(
-                context, area, offset,
-            )));
-        }
+        let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Scrolled(
+            context,
+            ScrollArea::Page,
+            iced::Vector::new(0., 40.),
+        )));
        assert!(app.busy);
        assert_eq!(
-            app.behavior.scenario.scroll_offset(),
-            iced::Vector::new(25., 100.)
+            app.behavior.scenario.details_offset,
+            iced::Vector::new(0., 40.)
        );
        assert_ne!(
            app.scenario_context(),
@@ -2618,14 +2700,14 @@ pub(crate) mod direct_tests {
        stale.document = Id::new_v4();
        let _ = app.update(Message::ScenarioCanvas(CanvasEvent::Scrolled(
            stale,
-            ScrollArea::Canvas,
+            ScrollArea::Page,
            iced::Vector::new(0., 900.),
        )));
        assert_eq!(
-            app.behavior.scenario.scroll_offset(),
-            iced::Vector::new(25., 100.)
+            app.behavior.scenario.details_offset,
+            iced::Vector::new(0., 40.)
        );
-        let root = std::path::PathBuf::from("scenario-scroll-save-fixture");
+        let root = std::path::PathBuf::from("scenario-details-save-fixture");
        let receipt = crate::app::FileSnapshot {
            document: context.document,
            revision: context.revision,
@@ -2646,12 +2728,17 @@ pub(crate) mod direct_tests {
        let context = app.scenario_context().unwrap();
        let mut scene = Scene::sequence(app.project(), f.owner, f.call);
        scene.interaction = Some((context, CanvasTool::Message(MessageStyle::CallReply), true));
-        scene.scroll_offset = app.behavior.scenario.scroll_offset();
+        assert_eq!(
+            app.behavior.scenario.presentation.pan,
+            iced::Vector::new(-25., -100.)
+        );
+        scene.camera_pan = app.behavior.scenario.presentation.pan;
        let slot = scene.slots.last().unwrap().slot;
        let bounds = Rectangle::new(Point::new(20., 250.), scene.size);
        let y = bounds.y + scene.slots.last().unwrap().y;
-        let a = Point::new(bounds.x + scene.lanes[&f.sender], y) - scene.scroll_offset;
-        let b = Point::new(bounds.x + scene.lanes[&f.receiver], y) - scene.scroll_offset;
+        let a = Point::new(bounds.x + scene.lanes[&f.sender], y) + scene.camera_pan;
+        let b = Point::new(bounds.x + scene.lanes[&f.receiver], y) + scene.camera_pan;
+        assert!(bounds.contains(a) && bounds.contains(b));
        let mut input = super::super::SequenceInput::default();
        let mut published = vec![];
        for event in [
@@ -2665,7 +2752,7 @@ pub(crate) mod direct_tests {
                &mut input,
                &canvas::Event::Mouse(event),
                bounds,
-                mouse::Cursor::Available(b + scene.scroll_offset),
+                mouse::Cursor::Available(b),
            )
            .and_then(|action| action.into_inner().0)
            {