fix(forms): reset replacement sessions and preserve visible scroll

crates/oa-desktop/src/behavior/form_session.rs

@@ -0,0 +1,148 @@
+//! Keep behavior field state within one editing session and reset it on replacement.
+use iced::advanced::widget::{Operation, Tree, tree};
+use iced::advanced::{Clipboard, Layout, Shell, Widget, layout, overlay, renderer};
+use iced::{Element, Event, Length, Rectangle, Size, Theme, Vector, mouse};
+use oa_core::Id;
+
+struct Identity(Id);
+
+struct Session<'a, Message, R: renderer::Renderer> {
+    identity: Id,
+    content: Element<'a, Message, Theme, R>,
+}
+
+pub(super) fn reset_on_change<'a, Message: 'a, R: renderer::Renderer + 'a>(
+    identity: Id,
+    content: impl Into<Element<'a, Message, Theme, R>>,
+) -> Element<'a, Message, Theme, R> {
+    Element::new(Session {
+        identity,
+        content: content.into(),
+    })
+}
+
+impl<Message, R: renderer::Renderer> Widget<Message, Theme, R> for Session<'_, Message, R> {
+    fn tag(&self) -> tree::Tag {
+        tree::Tag::of::<Identity>()
+    }
+
+    fn state(&self) -> tree::State {
+        tree::State::new(Identity(self.identity))
+    }
+
+    fn children(&self) -> Vec<Tree> {
+        vec![Tree::new(self.content.as_widget())]
+    }
+
+    fn diff(&self, tree: &mut Tree) {
+        let retained = tree.state.downcast_mut::<Identity>();
+        if retained.0 != self.identity {
+            retained.0 = self.identity;
+            // Iced's keyed column preserves same-length child replacements.
+            // An editing-session replacement must instead get fresh field state.
+            tree.children = self.children();
+        } else {
+            tree.diff_children(std::slice::from_ref(&self.content));
+        }
+    }
+
+    fn size(&self) -> Size<Length> {
+        self.content.as_widget().size()
+    }
+
+    fn layout(&mut self, tree: &mut Tree, renderer: &R, limits: &layout::Limits) -> layout::Node {
+        self.content
+            .as_widget_mut()
+            .layout(&mut tree.children[0], renderer, limits)
+    }
+
+    fn operate(
+        &mut self,
+        tree: &mut Tree,
+        layout: Layout<'_>,
+        renderer: &R,
+        operation: &mut dyn Operation,
+    ) {
+        self.content
+            .as_widget_mut()
+            .operate(&mut tree.children[0], layout, renderer, operation);
+    }
+
+    fn update(
+        &mut self,
+        tree: &mut Tree,
+        event: &Event,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        renderer: &R,
+        clipboard: &mut dyn Clipboard,
+        shell: &mut Shell<'_, Message>,
+        viewport: &Rectangle,
+    ) {
+        self.content.as_widget_mut().update(
+            &mut tree.children[0],
+            event,
+            layout,
+            cursor,
+            renderer,
+            clipboard,
+            shell,
+            viewport,
+        );
+    }
+
+    fn draw(
+        &self,
+        tree: &Tree,
+        renderer: &mut R,
+        theme: &Theme,
+        style: &renderer::Style,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+    ) {
+        self.content.as_widget().draw(
+            &tree.children[0],
+            renderer,
+            theme,
+            style,
+            layout,
+            cursor,
+            viewport,
+        );
+    }
+
+    fn mouse_interaction(
+        &self,
+        tree: &Tree,
+        layout: Layout<'_>,
+        cursor: mouse::Cursor,
+        viewport: &Rectangle,
+        renderer: &R,
+    ) -> mouse::Interaction {
+        self.content.as_widget().mouse_interaction(
+            &tree.children[0],
+            layout,
+            cursor,
+            viewport,
+            renderer,
+        )
+    }
+
+    fn overlay<'b>(
+        &'b mut self,
+        tree: &'b mut Tree,
+        layout: Layout<'b>,
+        renderer: &R,
+        viewport: &Rectangle,
+        translation: Vector,
+    ) -> Option<overlay::Element<'b, Message, Theme, R>> {
+        self.content.as_widget_mut().overlay(
+            &mut tree.children[0],
+            layout,
+            renderer,
+            viewport,
+            translation,
+        )
+    }
+}

crates/oa-desktop/src/behavior/scenario/focus.rs

@@ -232,25 +232,31 @@ impl Operation for Collect {
         };
         let mut shifts = BTreeMap::new();
         for ancestor in ancestors.iter().rev() {
+            let dx = reveal(
+                bounds.x,
+                bounds.width,
+                ancestor.bounds.x,
+                ancestor.bounds.width,
+            );
+            let dy = reveal(
+                bounds.y,
+                bounds.height,
+                ancestor.bounds.y,
+                ancestor.bounds.height,
+            );
+            // Drawing offsets are rounded; an already-visible axis must not
+            // acquire a scroll delta from a fractional capacity alone.
             let delta = Vector::new(
-                (ancestor.offset.x
-                    + reveal(
-                        bounds.x,
-                        bounds.width,
-                        ancestor.bounds.x,
-                        ancestor.bounds.width,
-                    ))
-                .clamp(0., ancestor.capacity.x)
-                    - ancestor.offset.x,
-                (ancestor.offset.y
-                    + reveal(
-                        bounds.y,
-                        bounds.height,
-                        ancestor.bounds.y,
-                        ancestor.bounds.height,
-                    ))
-                .clamp(0., ancestor.capacity.y)
-                    - ancestor.offset.y,
+                if dx == 0. {
+                    0.
+                } else {
+                    (ancestor.offset.x + dx).clamp(0., ancestor.capacity.x) - ancestor.offset.x
+                },
+                if dy == 0. {
+                    0.
+                } else {
+                    (ancestor.offset.y + dy).clamp(0., ancestor.capacity.y) - ancestor.offset.y
+                },
             );
             if delta != Vector::ZERO {
                 shifts.insert(ancestor.index, delta);

crates/oa-desktop/src/behavior/scenario/workspace.rs

@@ -1,7 +1,7 @@
 //! Scenario presentation. Layout/camera controls never construct model commands.
-use super::super::scenario_scroll;
+use super::super::{form_session, scenario_scroll};
 use super::*;
-use iced::widget::{Space, column, keyed_column, sensor};
+use iced::widget::{Space, column, sensor};
 
 pub(crate) const NAME_INPUT: &str = "scenario-form-name";
 
@@ -754,16 +754,13 @@ fn editor_panel<'a, R: iced::advanced::text::Renderer + 'a>(
     container(
         column![
             container(actions).id("scenario-actions").width(Fill),
-            keyed_column([(
+            form_session::reset_on_change(
                 session,
                 scrollable(fields)
                     .id("scenario-form")
                     .width(Fill)
-                    .height(Fill)
-                    .into(),
-            )])
-            .width(Fill)
-            .height(Fill),
+                    .height(Fill),
+            ),
         ]
         .spacing(6),
     )