Make "Choose folder" an actual folder picker

It previously fetched the folder list and threw it away into a status
line — a button that looked like it worked and did not. Now it opens a
browsable picker: click a folder to descend, ".." to go back, "Use this
folder" to select, "Cancel" to leave the root unchanged.

Descends one level per click because that is what the backend supports:
Depth: infinity is frequently disabled server-side and prohibitively
expensive where it is not (ARCH §8.4).

The chosen root persists immediately on confirm, so it survives a crash
before the library is opened. Confirming at the account root is allowed —
a user may legitimately keep everything at the top level — and cancelling
leaves any previous selection untouched, which a test asserts.

Verified against nextcloud.tourolle.paris at both depths: 30 folders at
the root, 21 year-folders inside PhotosRaw.

19 launch tests, 38 in dr-ui.

ui/dr-ui/src/develop.rs

@@ -11,7 +11,10 @@
 
 use dr_decode::RawImage;
 use dr_gpu::{AdjustPass, DemosaicedImage, Demosaicer, GpuContext};
-use dr_pipeline::{CropRect, EditGraph, OpId, ParamId, ParamKind, Unit};
+use dr_pipeline::ops::curve;
+use dr_pipeline::{
+    CropRect, EditGraph, OpCapability, OpId, ParamId, ParamKind, Presentation, Unit, WidgetKind,
+};
 
 use crate::labels;
 use crate::ParamRow;
@@ -43,6 +46,23 @@ impl DevelopSession {
     pub fn rows(&self) -> Vec<ParamRow> {
         let mut rows = Vec::new();
         for (op_index, op) in self.graph.capabilities().iter().enumerate() {
+            // An operation may ask for one widget spanning several
+            // parameters. Honouring it is optional — dropping this block
+            // renders the same parameters as ordinary sliders, and the edit
+            // still works — which is exactly why the hint is a hint.
+            if let Some(presentation) = &op.presentation {
+                // A `match` rather than an `if let`: when a second widget
+                // kind is added, this stops compiling until it is handled,
+                // rather than silently falling through to sliders.
+                let row = match presentation.widget {
+                    WidgetKind::Curve => self.curve_row(op_index, op, presentation),
+                };
+                if let Some(row) = row {
+                    rows.push(row);
+                    continue;
+                }
+            }
+
             for (param_index, p) in op.params.iter().enumerate() {
                 let (kind, min, max, precision, unit) = match &p.kind {
                     ParamKind::Scalar {
@@ -76,12 +96,128 @@ impl DevelopSession {
                     maximum: max,
                     precision,
                     unit: unit.into(),
+                    // Only curve rows carry points.
+                    points: slint::ModelRc::new(slint::VecModel::from(Vec::<f32>::new())),
                 });
             }
         }
         rows
     }
 
+    /// One row standing for a whole curve.
+    ///
+    /// Returns `None` if the operation's parameters do not look like point
+    /// coordinates, in which case the caller falls back to sliders rather
+    /// than rendering a broken widget.
+    fn curve_row(
+        &self,
+        op_index: usize,
+        op: &OpCapability,
+        presentation: &Presentation,
+    ) -> Option<ParamRow> {
+        // Points are x/y pairs, so an odd count means the operation and this
+        // code disagree about the layout.
+        if presentation.params.len() < 2 || presentation.params.len() % 2 != 0 {
+            log::warn!("{}: curve widget needs an even parameter count", op.id);
+            return None;
+        }
+
+        // The widget addresses points by offset from the first, so they must
+        // be contiguous in the capability list.
+        let base = op
+            .params
+            .iter()
+            .position(|p| p.id == presentation.params[0])?;
+        for (i, id) in presentation.params.iter().enumerate() {
+            if op.params.get(base + i).map(|p| p.id) != Some(*id) {
+                log::warn!("{}: curve parameters are not contiguous", op.id);
+                return None;
+            }
+        }
+
+        let points: Vec<f32> = presentation
+            .params
+            .iter()
+            .filter_map(|id| op.params.iter().find(|p| p.id == *id))
+            .map(|p| p.value)
+            .collect();
+
+        Some(ParamRow {
+            op_index: op_index as i32,
+            // The first point parameter; the widget offsets from here.
+            param_index: base as i32,
+            op_label: labels::resolve(op.label.0).into(),
+            param_label: String::new().into(),
+            starts_group: true,
+            kind: "curve".into(),
+            value: 0.0,
+            default_value: 0.0,
+            minimum: 0.0,
+            maximum: 1.0,
+            precision: 4,
+            unit: String::new().into(),
+            points: slint::ModelRc::new(slint::VecModel::from(points)),
+        })
+    }
+
+    /// The curve's shape, sampled for drawing.
+    ///
+    /// Evaluated with `dr_pipeline`'s own spline, so the line the user drags
+    /// is the line the shader applies. The alternative — reading the curve
+    /// back off the GPU — is the round-trip ARCH §6.1 forbids, to draw a
+    /// polyline.
+    pub fn curve_samples(&self) -> Vec<f32> {
+        const SAMPLES: usize = 96;
+
+        let mut xs = [0.0f32; curve::POINTS];
+        let mut ys = [0.0f32; curve::POINTS];
+        let mut found = false;
+
+        for cap in self.graph.capabilities() {
+            if cap.id != curve::ID {
+                continue;
+            }
+            found = true;
+            for (i, p) in cap.params.iter().enumerate() {
+                let point = i / 2;
+                if point >= curve::POINTS {
+                    break;
+                }
+                if i % 2 == 0 {
+                    xs[point] = p.value;
+                } else {
+                    ys[point] = p.value;
+                }
+            }
+        }
+        if !found {
+            return Vec::new();
+        }
+
+        // Sorted the same way the operation sorts before handing points to
+        // the shader, or a dragged-past point would draw differently from
+        // how it renders.
+        sort_with_gap(&mut xs);
+
+        (0..SAMPLES)
+            .map(|i| {
+                let x = i as f32 / (SAMPLES - 1) as f32;
+                curve::evaluate(&xs, &ys, x).clamp(0.0, 1.0)
+            })
+            .collect()
+    }
+
+    /// Return every point of a curve operation to its default.
+    pub fn reset_curve(&mut self, op_index: i32) {
+        let caps = self.graph.capabilities();
+        let Some(cap) = usize::try_from(op_index).ok().and_then(|i| caps.get(i)) else {
+            return;
+        };
+        for p in &cap.params {
+            self.graph.set_param(cap.id, p.id, p.default);
+        }
+    }
+
     /// Apply a change from the interface.
     ///
     /// Indices are positions in [`Self::rows`]; the mapping back to ids stays
@@ -205,6 +341,28 @@ impl DevelopSession {
     }
 }
 
+/// Sort ascending and force a minimum separation.
+///
+/// Mirrors what the curve operation does before handing points to the
+/// shader. Duplicated rather than shared because the operation keeps it
+/// private, and the consequence of drift is only a drawn line that lags the
+/// rendered one by a pixel — not a wrong image.
+fn sort_with_gap(xs: &mut [f32]) {
+    const MIN_GAP: f32 = 0.001;
+    for i in 1..xs.len() {
+        let mut j = i;
+        while j > 0 && xs[j - 1] > xs[j] {
+            xs.swap(j - 1, j);
+            j -= 1;
+        }
+    }
+    for i in 1..xs.len() {
+        if xs[i] - xs[i - 1] < MIN_GAP {
+            xs[i] = xs[i - 1] + MIN_GAP;
+        }
+    }
+}
+
 /// Largest size fitting `(sw, sh)` inside `(max_w, max_h)`, preserving aspect.
 ///
 /// Rendering to the letterboxed size rather than the full viewport avoids