Let a crop be trimmed from one edge

Four bar handles at the midpoints of the sides, each moving only its
own side along the axis across it. The overlay reports an edge as 0.5
on the axis it does not move, so the anchor Rust takes is the middle
of the far side.

Under a ratio lock the dragged axis leads. with_aspect grew the short
axis onto the ratio, which for an edge pulled inward made the untouched
axis the leader and pushed the edge straight back out.

core/dr-pipeline/src/framing.rs

@@ -260,8 +260,9 @@ impl CropRect {
     ///
     /// `anchor` is the point of the rect that stays put, in the rect's own
     /// `0..1` coordinates: `(1.0, 1.0)` while the top-left handle is dragged,
-    /// so the far corner is the one that does not move, and `(0.5, 0.5)` when
-    /// a ratio is chosen and the composition should stay where it is.
+    /// so the far corner is the one that does not move, `(0.0, 0.5)` while
+    /// the right-hand edge is dragged, and `(0.5, 0.5)` when a ratio is
+    /// chosen and the composition should stay where it is.
     ///
     /// **The rect grows onto the ratio rather than shrinking onto it.** The
     /// axis that is short is extended; the long one is never trimmed. Fitting
@@ -269,6 +270,7 @@ impl CropRect {
     /// along one axis alone would be immediately clamped back by the other,
     /// and the handle would simply refuse to move. The result is then scaled
     /// down, both axes together, only as far as the frame's edge demands.
+    /// The exception is an edge: see the note in the body.
     pub fn with_aspect(self, frame_w: u32, frame_h: u32, ratio: f32, anchor: (f32, f32)) -> Self {
         let rect = self.normalised();
         let ratio = finite(ratio, 0.0);
@@ -286,8 +288,19 @@ impl CropRect {
         let px = rect.x + ax * rect.width;
         let py = rect.y + ay * rect.height;
 
-        let mut w = rect.width.max(rect.height * r);
-        let mut h = w / r;
+        // An anchor in the middle of one side is an *edge* being dragged, and
+        // then the axis across that edge leads: it is the only one the user
+        // moved. Growing the short axis instead would take the other side
+        // for the leader whenever the edge went inward, and the edge would be
+        // pushed straight back out — a handle that only ever grows the crop.
+        let (mut w, mut h) = if ax == 0.5 && ay != 0.5 {
+            (rect.height * r, rect.height)
+        } else if ay == 0.5 && ax != 0.5 {
+            (rect.width, rect.width / r)
+        } else {
+            let w = rect.width.max(rect.height * r);
+            (w, w / r)
+        };
 
         // Scaled to fit, never clamped to fit: clamping one axis against the
         // frame would break the very ratio this exists to hold.
@@ -2255,6 +2268,42 @@ mod tests {
         assert!((c.y - start.y).abs() < 1e-5, "{c:?}");
     }
 
+    #[test]
+    fn a_locked_edge_leads_and_the_far_side_stays_put() {
+        // An edge dragged inward under a lock must narrow the crop. With the
+        // short axis leading, the untouched height would win and push the
+        // edge straight back out.
+        let start = CropRect {
+            x: 0.2,
+            y: 0.2,
+            width: 0.4,
+            height: 0.6,
+        };
+        // Right edge held, dragged in: the left side and the vertical
+        // centre stay, the width is what was asked for.
+        let c = start.with_aspect(4000, 4000, 1.0, (0.0, 0.5));
+        assert!((c.x - start.x).abs() < 1e-5, "{c:?}");
+        assert!((c.width - start.width).abs() < 1e-5, "{c:?}");
+        assert!((c.height - start.width).abs() < 1e-5, "{c:?}");
+        assert!(
+            (c.y + c.height / 2.0 - (start.y + start.height / 2.0)).abs() < 1e-5,
+            "{c:?}"
+        );
+
+        // Top edge held: the bottom and the horizontal centre stay, the
+        // height is what was asked for.
+        let c = start.with_aspect(4000, 4000, 1.0, (0.5, 1.0));
+        assert!(
+            (c.y + c.height - (start.y + start.height)).abs() < 1e-5,
+            "{c:?}"
+        );
+        assert!((c.width - c.height).abs() < 1e-5, "{c:?}");
+        assert!(
+            (c.x + c.width / 2.0 - (start.x + start.width / 2.0)).abs() < 1e-5,
+            "{c:?}"
+        );
+    }
+
     #[test]
     fn a_locked_rect_grows_onto_the_ratio_rather_than_shrinking_onto_it() {
         // Shrinking to fit makes a one-axis drag do nothing at all: the other