Hold one key to see the photograph before you touched it

FR-DEV-7 asks for the current edit against the unedited original and nothing
implemented it. What the develop view had was history navigation, which
*changes* the edit rather than previewing against it — so the only way to
look was to undo, look, and redo, and that puts two real steps on the stack
at exactly the moment a photographer suspects they have overcooked a frame
and is least sure of what they are doing.

Holding the "Before" button, or backslash, renders the graph with every
adjustment stripped and hands it straight back afterwards: the same
suspend-render-restore shape the crop overlay already uses to show an
uncropped frame and an export uses to suspend the zoom. Nothing is recorded,
no rows are re-synced, and the photograph is still modified when the key
comes up — the panel goes on describing the edit the photographer has,
because only the canvas is answering a question.

The framing deliberately stays on. A held comparison is a question about
tone and colour, and re-cropping the canvas under someone's thumb would move
the detail they are comparing; worse, the zoom is a rectangle of the *framed*
image, so dropping the crop at 4× would quietly show a different part of the
photograph rather than the same part unedited. What the crop took away is
already compared in Compose, which shows the whole frame.

Not a split screen: that halves the working image on the tablet this column
was sized for, and the comparison photographers describe making is a flick
back and forth rather than two pictures side by side. Press-and-hold is one
gesture on a finger and on a mouse, which is what FR-DEV-3b's mapping wants,
and it has no mode to be stranded in — the button reports both edges, so a
press the system cancels puts the original down too.

ui/dr-ui/src/develop.rs

@@ -3605,6 +3605,72 @@ impl DevelopSession {
         Ok((image, rw, rh))
     }
 
+    /// TRACES: FR-DEV-7
+    /// Render the photograph as the file has it, with every adjustment off.
+    ///
+    /// **What a held comparison shows, and it is not a history state.**
+    /// FR-DEV-7 asks for the current edit against the unedited original, and
+    /// the only thing the interface had was [`Self::go_to_history`] — which
+    /// *changes* the edit rather than previewing against it. A photographer
+    /// who suspects they have overcooked a frame therefore had to undo, look,
+    /// and redo, which puts two real steps on the stack at exactly the moment
+    /// they are least sure of what they are doing.
+    ///
+    /// This puts none there. It borrows the graph for the length of one
+    /// render and hands it back: the same shape [`Self::render_uncropped`]
+    /// uses for the crop and [`Self::render_the_file`] uses for the zoom, and
+    /// for the same reason — the graph is the one description of the
+    /// photograph, so a second rendering of it is a suspension rather than a
+    /// copy. Nothing is recorded, nothing is marked modified, and a caller
+    /// asking whether the image differs from its defaults gets the same
+    /// answer before and after.
+    ///
+    /// **The framing stays on**, and that is a decision rather than an
+    /// oversight. A held before/after is a question about tone and colour —
+    /// "have I pushed this too far" — and re-cropping the canvas under the
+    /// photographer's thumb would move the very detail they are comparing.
+    /// It would also make the view meaningless: the zoom is a rectangle of the
+    /// *framed* image, so dropping the crop at 4× would show a different part
+    /// of the photograph rather than the same part unedited. What the crop
+    /// took away is compared in Compose, which already shows the whole frame.
+    ///
+    /// Restored whatever happens, for the reason `render_uncropped` restores
+    /// its crop: leaving the graph stripped after a failed render would
+    /// discard the entire edit, silently.
+    pub fn render_original(&mut self, width: u32, height: u32) -> Result<slint::Image, String> {
+        let saved = self.graph.state();
+        self.strip_adjustments();
+        let rendered = self.render(width, height);
+        let debt = self.graph.set_state(&saved);
+        self.pay_film_debt(&debt);
+        rendered
+    }
+
+    /// TRACES: FR-DEV-7
+    /// Take everything off the graph except the shape of the frame.
+    ///
+    /// Four removals rather than [`EditGraph::reset`], which would take the
+    /// framing with it. The empty preset applied at
+    /// [`Scope::adjustments`] — the scope that is defined as "all of it but
+    /// the crop" — clears every parameter the photographer can move, and the
+    /// three things that are not parameters go by hand: local adjustments,
+    /// repairs, and the film stock. A local adjustment is as much an edit as
+    /// the slider that drives it, so an "original" still wearing its masks
+    /// would be answering a different question.
+    ///
+    /// **Only ever inside a suspension.** This leaves the graph describing a
+    /// photograph nobody asked for, so every caller restores from a
+    /// [`EditGraph::state`] taken first.
+    fn strip_adjustments(&mut self) {
+        Preset::default().apply(&mut self.graph, Scope::adjustments());
+        *self.graph.masks_mut() = dr_pipeline::mask::MaskStack::new();
+        *self.graph.spots_mut() = dr_pipeline::SpotSet::new();
+        // Through the session rather than the graph: the baked tables live on
+        // the adjust pass as well, and clearing one without the other is the
+        // silent disagreement `set_film` exists to prevent.
+        self.set_film(None);
+    }
+
     /// TRACES: FR-PLAT-AND-5 | NFR-RES-1
     /// Give back the GPU memory this session is holding only to be fast.
     ///
@@ -5531,6 +5597,47 @@ mod tests {
         assert!(!session.framing_edits_image());
     }
 
+    /// TRACES: FR-DEV-7 | FR-DEV-5
+    /// A held comparison hands the edit straight back.
+    ///
+    /// This is the whole difference between comparing and the
+    /// undo-look-redo that had to stand in for it. Two steps on the stack, at
+    /// the moment a photographer is least sure of what they are doing, was
+    /// the price of looking — and this asserts the price is now nothing:
+    /// the same parameters, the same history, still modified.
+    #[test]
+    fn showing_the_original_leaves_the_edit_exactly_as_it_was() {
+        let Some(ctx) = headless() else { return };
+        let (mut session, _) = grey_session(&ctx);
+
+        // Addressed by index, so this names no operation (FR-DEV-3a).
+        let row = session.rows()[0].clone();
+        session.set_param(row.op_index, row.param_index, row.maximum);
+
+        let edit = session.copy_settings();
+        let steps = session.history_rows().len();
+        assert!(!session.is_neutral(), "the premise: there is an edit");
+
+        session
+            .render_original(64, 64)
+            .expect("render the original");
+
+        assert_eq!(
+            session.copy_settings(),
+            edit,
+            "every parameter comes back where it was"
+        );
+        assert_eq!(
+            session.history_rows().len(),
+            steps,
+            "looking is not a step to take back"
+        );
+        assert!(
+            !session.is_neutral(),
+            "and the photograph is still modified"
+        );
+    }
+
     /// TRACES: FR-DEV-3 | FR-CAT-8
     /// Reopening an edited photograph renders its subject mask, with no model.
     ///

ui/dr-ui/src/lib.rs

@@ -370,6 +370,14 @@ fn reset_view_state(window: &AppWindow) {
     // previous image's history.
     window.set_can_undo(false);
     window.set_can_redo(false);
+    // TRACES: FR-DEV-7
+    // And the comparison goes down with them. Unlike the inspection point
+    // below it, this is not a way of looking at a folder: it is a question
+    // about one photograph's edit, asked while holding something. A key
+    // release that arrived after the next frame had opened would put the view
+    // back anyway, but a press that opens the next photograph — the roll is a
+    // tap away — must not carry a held original onto it.
+    window.set_showing_original(false);
     // TRACES: FR-DSP-7
     // Emptied rather than left standing: the previous photograph's histogram
     // beside the next one's filename is a confident, precise lie, and the gap
@@ -1821,11 +1829,19 @@ pub fn run(paths: Vec<PathBuf>) -> Result<()> {
                 h = (h / 2).max(1);
             }
 
+            // TRACES: FR-DEV-7
+            // Three renders of one graph, chosen here because this is the one
+            // path every frame takes — so a comparison held while a slider is
+            // still settling shows the original at full resolution too, rather
+            // than reverting the moment anything else asks for a redraw.
+            //
             // Crop mode shows the whole frame, or the area being cropped away
             // would not be on screen for the handles to drag across. The
             // overlay draws the rect on top of it.
             let rendered = if window.get_view_mode() == ViewMode::Crop {
                 s.render_uncropped(w, h).map(|(image, _, _)| image)
+            } else if window.get_showing_original() {
+                s.render_original(w, h)
             } else {
                 s.render(w, h)
             };
@@ -2789,6 +2805,34 @@ pub fn run(paths: Vec<PathBuf>) -> Result<()> {
             }
         });
     }
+    {
+        // TRACES: FR-DEV-7
+        // Holding the comparison, and letting it go.
+        //
+        // **No rows are synced and no history is touched**, and both absences
+        // are the feature. The panel is describing the edit the photographer
+        // still has; only the canvas changes, and it changes back. This is the
+        // whole difference between a comparison and the undo-look-redo that
+        // had to stand in for one — that put two real steps on the stack at
+        // the moment somebody was least sure of what they were doing.
+        //
+        // A full frame rather than a draft: comparing a half-resolution
+        // original against a sharp edit would show a difference the edit does
+        // not have, which is the one thing this must not do.
+        let weak = window.as_weak();
+        let render_now = render_now.clone();
+        window.on_compare_original(move |on| {
+            let Some(w) = weak.upgrade() else { return };
+            // A held key repeats. Answering a repeat with a re-render would
+            // spend a full-resolution pass per keystroke to arrive back at the
+            // frame already on screen.
+            if w.get_showing_original() == on {
+                return;
+            }
+            w.set_showing_original(on);
+            render_now(&w, false);
+        });
+    }
 
     // TRACES: FR-DEV-5 | FR-DEV-7
     // Clicking a row. Arriving six steps away costs what arriving from one

ui/dr-ui/ui/app.slint

@@ -219,6 +219,24 @@ export component AppWindow inherits Window {
     callback undo();
     callback redo();
 
+    // --- before and after (FR-DEV-7) ---
+
+    /// TRACES: FR-DEV-7
+    /// Whether the canvas is currently showing the unedited original.
+    ///
+    /// Rust owns it, and the ownership is the point: this is *not* a history
+    /// position and must never become one. Held down, the canvas renders the
+    /// photograph with the adjustments taken off and the framing left on; let
+    /// go, the edit comes back. Nothing is recorded, so a photographer can
+    /// check whether they have overcooked a frame without paying two steps of
+    /// undo for the look.
+    in property <bool> showing-original: false;
+    /// The comparison is being held, or has been let go.
+    ///
+    /// Both edges through one callback rather than a press and a release, so
+    /// the two cannot get out of step and strand the view on the original.
+    callback compare-original(bool);
+
     /// Every step, newest first. Rust owns the order and stamps each row with
     /// its own position in the stack, so nothing here does arithmetic to turn
     /// a row back into a step.
@@ -2182,11 +2200,30 @@ in property <bool> panel-visible: true;
                         // the canvas is noticed.
                         key-released(event) => {
                             root.shift-held = event.modifiers.shift;
+                            // TRACES: FR-DEV-7
+                            // Letting go of backslash puts the edit back. The
+                            // release has to be handled here and not inferred
+                            // from the next press, or a photographer who holds
+                            // it and then reaches for a slider would be
+                            // adjusting an image they cannot see.
+                            if (event.text == "\\") {
+                                root.compare-original(false);
+                                return accept;
+                            }
                             return reject;
                         }
 
                         key-pressed(event) => {
                             root.shift-held = event.modifiers.shift;
+                            // TRACES: FR-DEV-7
+                            // Hold backslash to see the unedited original.
+                            // Rust ignores a repeat that says what it already
+                            // knows, so the key repeating under a long look
+                            // costs nothing.
+                            if (event.text == "\\") {
+                                root.compare-original(true);
+                                return accept;
+                            }
                             // Ctrl+Z and Ctrl+Shift+Z (FR-DEV-5). Both cases
                             // of the letter, because the logical key that
                             // reaches us carries the shift: holding it for
@@ -2335,6 +2372,33 @@ in property <bool> panel-visible: true;
                             // frame nobody was looking at the middle of.
                             clicked => { root.inspect-toggled(-1, -1); }
                         }
+
+                        // TRACES: FR-DEV-7 | FR-DEV-3b | NFR-A11Y-2
+                        // The unedited original, for as long as it is held.
+                        //
+                        // **A hold rather than a split screen.** A split view
+                        // halves the working image, which on the tablet this
+                        // column was sized for leaves neither half worth
+                        // judging; and the comparison a photographer actually
+                        // describes making is a flick back and forth, not two
+                        // pictures side by side. A hold is also the cheaper
+                        // thing to build: one extra render of a graph that is
+                        // already there, against a second canvas that would
+                        // have to be laid out, sized and kept in step.
+                        //
+                        // Press-and-hold is the same gesture with a finger and
+                        // with a mouse, which is what FR-DEV-3b's mapping
+                        // wants — no long-press timer, no mode, and no way to
+                        // be left in it. The keyboard's backslash does the
+                        // same thing on both edges; see the focus scope below.
+                        Button {
+                            text: "Before";
+                            enabled: root.adjust-enabled;
+                            active: root.showing-original;
+                            accessible-checkable: true;
+                            accessible-checked: root.showing-original;
+                            held(down) => { root.compare-original(down); }
+                        }
                     }
 
                     // The photo roll, along the foot of the canvas.

ui/dr-ui/ui/widgets.slint

@@ -68,6 +68,25 @@ export component Button inherits Rectangle {
     in property <bool> active: false;
 
     callback clicked();
+    /// TRACES: FR-DEV-7 | FR-UI-3
+    /// The button is down, or is no longer down.
+    ///
+    /// Almost every button acts on release and ignores this. A *held* control
+    /// is the exception — "show me the original while I am holding this" — and
+    /// `clicked` describes only the end of that gesture, by which time the
+    /// thing being looked at has gone.
+    ///
+    /// Here rather than in a second component because the two are one button
+    /// in every other respect: the same box, the same states, the same 44pt
+    /// target grown around a compact rectangle. A `HoldButton` beside this one
+    /// would be sixty duplicated lines and a second place for the press
+    /// treatment to drift, which is the failure this file's preamble is about.
+    ///
+    /// Reported from the pointer rather than from `touch.pressed`, so that a
+    /// press cancelled by the system — a call arriving, a gesture claimed by
+    /// the shell — puts the button up. A held comparison that stuck on would
+    /// leave the photographer editing the original.
+    callback held(bool);
 
     accessible-role: button;
     accessible-label: root.text;
@@ -115,6 +134,15 @@ export component Button inherits Rectangle {
         y: (parent.height - self.height) / 2;
         mouse-cursor: root.enabled ? MouseCursor.pointer : MouseCursor.default;
         clicked => { root.clicked(); }
+        pointer-event(ev) => {
+            if (ev.kind == PointerEventKind.down) {
+                root.held(true);
+            }
+            if (ev.kind == PointerEventKind.up
+                || ev.kind == PointerEventKind.cancel) {
+                root.held(false);
+            }
+        }
     }
 
     HorizontalLayout {