refactor: split complex fillet, model, dimstyle and rectangle code into helpers

Pure extraction, no behaviour change: same order of side effects, same
early returns and error values. Clears cognitive-complexity findings on
tangent_circles, Model::build_budgeted, DimStyle::apply_fields and
run_rectang2 (S3776), and replaces a redundant closure with a method
reference in menus.rs (S1612).

crates/constraints/src/model.rs

@@ -191,6 +191,77 @@ impl Model {
         Self::build_budgeted(d, handles, &mut members_left)
     }
 
+    /// Add the parameters of one supported entity to `m`, and return its shape; `None` when it is
+    /// left out (too large, degenerate or unsupported).
+    fn add_params(m: &mut Model, d: &Drawing, h: Handle, kind: &EntityKind, off: usize, members_left: &mut usize) -> Option<Shape> {
+        let shape = match kind {
+            EntityKind::Line(l) => {
+                m.x0.extend([l.a.x, l.a.y, l.b.x, l.b.y]);
+                Shape::Line
+            }
+            EntityKind::Circle(c) => {
+                m.x0.extend([c.center.x, c.center.y, c.radius]);
+                Shape::Circle
+            }
+            EntityKind::Arc(a) => {
+                m.x0.extend([a.center.x, a.center.y, a.radius, a.start, a.end]);
+                Shape::Arc
+            }
+            EntityKind::LwPolyline(p) => {
+                if p.vertices.len() < 2 || off + p.vertices.len() * 2 > MAX_PARAMS {
+                    return None;
+                }
+                for v in &p.vertices {
+                    m.x0.extend([v.p.x, v.p.y]);
+                }
+                Shape::Poly { n: p.vertices.len(), closed: p.closed }
+            }
+            EntityKind::Point(p) => {
+                m.x0.extend([p.p.x, p.p.y]);
+                Shape::Point
+            }
+            EntityKind::Ellipse(el) => {
+                let ell = cadcraft_geom::Ellipse { center: el.center.xy(), major: el.major.xy(), ratio: el.ratio, start: el.start, end: el.end };
+                let arc = !ell.is_full();
+                m.x0.extend([el.center.x, el.center.y, el.major.x, el.major.y, el.ratio]);
+                if arc {
+                    m.x0.extend([el.start, el.end]);
+                }
+                Shape::Ellipse { arc }
+            }
+            EntityKind::Spline(sp) => {
+                let fit = fit_mode(sp);
+                let pts = if fit { &sp.fit } else { &sp.control };
+                let n = pts.len();
+                if !(2..=MAX_SPLINE_POINTS).contains(&n) || off + n * 2 > MAX_PARAMS || (!fit && !sp.is_valid()) {
+                    return None;
+                }
+                for p in pts {
+                    m.x0.extend([p.x, p.y]);
+                }
+                // Fit points interpolate exactly, so the curve's ends are the first and last
+                // fit point; a control polygon's ends are its first and last points when the
+                // knots are clamped.
+                let ends = !sp.closed && (fit || (clamped(sp, false) && clamped(sp, true)));
+                // Missing weights default to 1 in eval; only excess weights are unused.
+                let mut kept = sp.clone();
+                kept.weights.truncate(kept.control.len());
+                m.splines.insert(h, kept);
+                Shape::Spline { n, fit, ends }
+            }
+            EntityKind::Insert(ins) => {
+                let base = Vec2::new(ins.insert.x, ins.insert.y);
+                let pts: Vec<Vec2> = rigid_points_budgeted(d, ins, members_left).into_iter().map(|p| (p - base).rotate(-ins.rotation)).collect();
+                m.x0.extend([ins.insert.x, ins.insert.y, ins.rotation]);
+                let n = pts.len();
+                m.rigid.insert(h, pts);
+                Shape::Insert { n }
+            }
+            _ => return None,
+        };
+        Some(shape)
+    }
+
     /// Build solver parameters for supported entities while sharing rigid-member sampling work with other models.
     pub(crate) fn build_budgeted(d: &Drawing, handles: &[Handle], members_left: &mut usize) -> Model {
         let mut m = Model::default();
@@ -200,71 +271,7 @@ impl Model {
             }
             let Some(e) = d.entity(h) else { continue };
             let off = m.x0.len();
-            let shape = match &e.kind {
-                EntityKind::Line(l) => {
-                    m.x0.extend([l.a.x, l.a.y, l.b.x, l.b.y]);
-                    Shape::Line
-                }
-                EntityKind::Circle(c) => {
-                    m.x0.extend([c.center.x, c.center.y, c.radius]);
-                    Shape::Circle
-                }
-                EntityKind::Arc(a) => {
-                    m.x0.extend([a.center.x, a.center.y, a.radius, a.start, a.end]);
-                    Shape::Arc
-                }
-                EntityKind::LwPolyline(p) => {
-                    if p.vertices.len() < 2 || off + p.vertices.len() * 2 > MAX_PARAMS {
-                        continue;
-                    }
-                    for v in &p.vertices {
-                        m.x0.extend([v.p.x, v.p.y]);
-                    }
-                    Shape::Poly { n: p.vertices.len(), closed: p.closed }
-                }
-                EntityKind::Point(p) => {
-                    m.x0.extend([p.p.x, p.p.y]);
-                    Shape::Point
-                }
-                EntityKind::Ellipse(el) => {
-                    let ell = cadcraft_geom::Ellipse { center: el.center.xy(), major: el.major.xy(), ratio: el.ratio, start: el.start, end: el.end };
-                    let arc = !ell.is_full();
-                    m.x0.extend([el.center.x, el.center.y, el.major.x, el.major.y, el.ratio]);
-                    if arc {
-                        m.x0.extend([el.start, el.end]);
-                    }
-                    Shape::Ellipse { arc }
-                }
-                EntityKind::Spline(sp) => {
-                    let fit = fit_mode(sp);
-                    let pts = if fit { &sp.fit } else { &sp.control };
-                    let n = pts.len();
-                    if !(2..=MAX_SPLINE_POINTS).contains(&n) || off + n * 2 > MAX_PARAMS || (!fit && !sp.is_valid()) {
-                        continue;
-                    }
-                    for p in pts {
-                        m.x0.extend([p.x, p.y]);
-                    }
-                    // Fit points interpolate exactly, so the curve's ends are the first and last
-                    // fit point; a control polygon's ends are its first and last points when the
-                    // knots are clamped.
-                    let ends = !sp.closed && (fit || (clamped(sp, false) && clamped(sp, true)));
-                    // Missing weights default to 1 in eval; only excess weights are unused.
-                    let mut kept = sp.clone();
-                    kept.weights.truncate(kept.control.len());
-                    m.splines.insert(h, kept);
-                    Shape::Spline { n, fit, ends }
-                }
-                EntityKind::Insert(ins) => {
-                    let base = Vec2::new(ins.insert.x, ins.insert.y);
-                    let pts: Vec<Vec2> = rigid_points_budgeted(d, ins, members_left).into_iter().map(|p| (p - base).rotate(-ins.rotation)).collect();
-                    m.x0.extend([ins.insert.x, ins.insert.y, ins.rotation]);
-                    let n = pts.len();
-                    m.rigid.insert(h, pts);
-                    Shape::Insert { n }
-                }
-                _ => continue,
-            };
+            let Some(shape) = Self::add_params(&mut m, d, h, &e.kind, off, members_left) else { continue };
             if m.x0.len() > MAX_PARAMS || m.x0.get(off..).unwrap_or(&[]).iter().any(|v| !v.is_finite()) {
                 m.x0.truncate(off);
                 continue;

crates/doc/src/tables.rs

@@ -441,6 +441,49 @@ impl DimStyle {
             .or_else(|| ["name", "annotative"].into_iter().find(|f| f.eq_ignore_ascii_case(name)))
     }
 
+    /// The value `v` takes for a field whose current value is `old`: coerced to the field's type where
+    /// the text or number can be read as it.
+    fn coerce_value(old: &serde_json::Value, v: &serde_json::Value, field: &str) -> serde_json::Value {
+        use serde_json::Value;
+        match (old, v) {
+            (Value::Bool(_), Value::Number(n)) => Value::Bool(n.as_f64().is_some_and(|x| x != 0.0)),
+            (Value::Bool(_), Value::String(t)) => Value::Bool(matches!(t.to_ascii_lowercase().as_str(), "1" | "on" | "true" | "yes")),
+            (Value::Number(_), Value::String(t)) => match t.trim().parse::<f64>() {
+                Ok(x) => serde_json::json!(x),
+                // Lineweight names.
+                Err(_) if matches!(field, "dimLineweight" | "extLineweight") => match t.trim().to_ascii_lowercase().as_str() {
+                    "bylayer" => serde_json::json!(-1),
+                    "byblock" => serde_json::json!(-2),
+                    "default" => serde_json::json!(-3),
+                    _ => v.clone(),
+                },
+                Err(_) => v.clone(),
+            },
+            (Value::Number(_), Value::Bool(b)) => serde_json::json!(u8::from(*b)),
+            (Value::String(_), Value::Number(n)) => Value::String(n.to_string()),
+            (Value::Object(_), Value::Number(n)) => {
+                let c = n.as_i64().and_then(|i| i16::try_from(i).ok()).map(Color::from_aci);
+                c.and_then(|c| serde_json::to_value(c).ok()).unwrap_or_else(|| v.clone())
+            }
+            (Value::Object(_), Value::String(t)) => Color::parse(t).and_then(|c| serde_json::to_value(c).ok()).unwrap_or_else(|| v.clone()),
+            _ => v.clone(),
+        }
+    }
+
+    /// Whether `coerced` is outside the range its `field` can take.
+    fn out_of_range(field: &str, coerced: &serde_json::Value) -> bool {
+        let x = coerced.as_f64();
+        match field {
+            "textHeight" | "tolScale" => x.is_some_and(|x| x <= 0.0),
+            "scale" | "arrowSize" | "tickSize" | "fixedExtLength" => x.is_some_and(|x| x < 0.0),
+            "fit" | "angularZeroSuppression" => x.is_some_and(|x| x > 3.0),
+            "textMove" | "tolJust" | "arcSymbol" | "textFill" => x.is_some_and(|x| x > 2.0),
+            "dimLineweight" | "extLineweight" => x.is_some_and(|x| !(-3.0..=211.0).contains(&x)),
+            "jogAngle" => x.is_some_and(|x| !(5.0..=90.0).contains(&x)),
+            _ => false,
+        }
+    }
+
     /// Set fields from a JSON object of field or DIM* variable names (numbers, booleans as
     /// 0/1, colours as ACI numbers or names). Returns the names that were not recognised or
     /// had unusable values.
@@ -458,29 +501,7 @@ impl DimStyle {
                 rejected.push(k.clone());
                 continue;
             };
-            let coerced = match (&old, v) {
-                (Value::Bool(_), Value::Number(n)) => Value::Bool(n.as_f64().is_some_and(|x| x != 0.0)),
-                (Value::Bool(_), Value::String(t)) => Value::Bool(matches!(t.to_ascii_lowercase().as_str(), "1" | "on" | "true" | "yes")),
-                (Value::Number(_), Value::String(t)) => match t.trim().parse::<f64>() {
-                    Ok(x) => serde_json::json!(x),
-                    // Lineweight names.
-                    Err(_) if matches!(field, "dimLineweight" | "extLineweight") => match t.trim().to_ascii_lowercase().as_str() {
-                        "bylayer" => serde_json::json!(-1),
-                        "byblock" => serde_json::json!(-2),
-                        "default" => serde_json::json!(-3),
-                        _ => v.clone(),
-                    },
-                    Err(_) => v.clone(),
-                },
-                (Value::Number(_), Value::Bool(b)) => serde_json::json!(u8::from(*b)),
-                (Value::String(_), Value::Number(n)) => Value::String(n.to_string()),
-                (Value::Object(_), Value::Number(n)) => {
-                    let c = n.as_i64().and_then(|i| i16::try_from(i).ok()).map(Color::from_aci);
-                    c.and_then(|c| serde_json::to_value(c).ok()).unwrap_or_else(|| v.clone())
-                }
-                (Value::Object(_), Value::String(t)) => Color::parse(t).and_then(|c| serde_json::to_value(c).ok()).unwrap_or_else(|| v.clone()),
-                _ => v.clone(),
-            };
+            let coerced = Self::coerce_value(&old, v, field);
             // Integers stored in u8 fields: round floats.
             let coerced = match (&old, &coerced) {
                 // Lineweights (i16): whole hundredths of a mm or -1/-2/-3.
@@ -502,16 +523,7 @@ impl DimStyle {
                 _ => coerced,
             };
             // Sizes that can't be negative (text height and tolerance scale: not zero either).
-            let x = coerced.as_f64();
-            let out_of_range = match field {
-                "textHeight" | "tolScale" => x.is_some_and(|x| x <= 0.0),
-                "scale" | "arrowSize" | "tickSize" | "fixedExtLength" => x.is_some_and(|x| x < 0.0),
-                "fit" | "angularZeroSuppression" => x.is_some_and(|x| x > 3.0),
-                "textMove" | "tolJust" | "arcSymbol" | "textFill" => x.is_some_and(|x| x > 2.0),
-                "dimLineweight" | "extLineweight" => x.is_some_and(|x| !(-3.0..=211.0).contains(&x)),
-                "jogAngle" => x.is_some_and(|x| !(5.0..=90.0).contains(&x)),
-                _ => false,
-            };
+            let out_of_range = Self::out_of_range(field, &coerced);
             if out_of_range {
                 rejected.push(k.clone());
                 continue;

crates/engine/src/cmd/draw2.rs

@@ -1585,25 +1585,10 @@ fn rect_kind(first: Vec2, (w, h): (f64, f64), rot: f64, fillet: f64, chamfer: (f
     k
 }
 
-/// Draws a rectangle from the JSON form: `p1` is a corner, or the centre when `center` is
-/// true, and the size comes from `p2`, `dimensions` or `area` plus `length`/`breadth`.
-pub(crate) fn run_rectang2(s: &mut Session, p: &Value) -> Result<Value> {
-    let a = point_req("rectang", p, "p1")?;
-    // Centre mode: `p1` is the rectangle's centre, so the rectangle spans it evenly.
-    let centered = bool_or(p, "center", false);
-    let rot = f64_or(p, "rotation", 0.0).to_radians();
-    let ch = p
-        .get("chamfer")
-        .and_then(Value::as_array)
-        .map(|c| (c.first().and_then(Value::as_f64).unwrap_or(0.0), c.get(1).and_then(Value::as_f64).unwrap_or(0.0)))
-        .map(|(x, y)| (if x.is_finite() { x } else { 0.0 }, if y.is_finite() { y } else { 0.0 }))
-        .unwrap_or((0.0, 0.0));
-    if ch.0 < 0.0 || ch.1 < 0.0 {
-        return Err(bad("rectang", "`chamfer` distances must be zero or positive"));
-    }
-    let fillet = size_param("rectang", p, "fillet", true)?.unwrap_or(0.0);
-    let width = size_param("rectang", p, "width", true)?.unwrap_or(0.0);
-    let (w, h) = if let Some(d) = p.get("dimensions").and_then(Value::as_array) {
+/// The width and height of a rectangle from its `dimensions`, its `p2` corner, its `area` with
+/// `length` or `breadth`, or its second corner `p2`, rotated by `rot` about `a`.
+fn rect_size(p: &Value, a: Vec2, rot: f64, centered: bool) -> Result<(f64, f64)> {
+    Ok(if let Some(d) = p.get("dimensions").and_then(Value::as_array) {
         let l = d.first().and_then(Value::as_f64).filter(|v| v.is_finite()).ok_or_else(|| bad("rectang", "dimensions: [length, width]"))?;
         let wd = d.get(1).and_then(Value::as_f64).filter(|v| v.is_finite()).ok_or_else(|| bad("rectang", "dimensions: [length, width]"))?;
         let (sx, sy) = match point_param(p, "p2") {
@@ -1628,7 +1613,28 @@ pub(crate) fn run_rectang2(s: &mut Session, p: &Value) -> Result<Value> {
         let loc = (b - a).rotate(-rot);
         // In centre mode the picked point is one corner, mirrored across the centre.
         if centered { (2.0 * loc.x, 2.0 * loc.y) } else { (loc.x, loc.y) }
-    };
+    })
+}
+
+/// Draws a rectangle from the JSON form: `p1` is a corner, or the centre when `center` is
+/// true, and the size comes from `p2`, `dimensions` or `area` plus `length`/`breadth`.
+pub(crate) fn run_rectang2(s: &mut Session, p: &Value) -> Result<Value> {
+    let a = point_req("rectang", p, "p1")?;
+    // Centre mode: `p1` is the rectangle's centre, so the rectangle spans it evenly.
+    let centered = bool_or(p, "center", false);
+    let rot = f64_or(p, "rotation", 0.0).to_radians();
+    let ch = p
+        .get("chamfer")
+        .and_then(Value::as_array)
+        .map(|c| (c.first().and_then(Value::as_f64).unwrap_or(0.0), c.get(1).and_then(Value::as_f64).unwrap_or(0.0)))
+        .map(|(x, y)| (if x.is_finite() { x } else { 0.0 }, if y.is_finite() { y } else { 0.0 }))
+        .unwrap_or((0.0, 0.0));
+    if ch.0 < 0.0 || ch.1 < 0.0 {
+        return Err(bad("rectang", "`chamfer` distances must be zero or positive"));
+    }
+    let fillet = size_param("rectang", p, "fillet", true)?.unwrap_or(0.0);
+    let width = size_param("rectang", p, "width", true)?.unwrap_or(0.0);
+    let (w, h) = rect_size(p, a, rot, centered)?;
     if w.abs() < 1e-12 || h.abs() < 1e-12 || !w.is_finite() || !h.is_finite() {
         return Err(bad("rectang", "rectangle has no area"));
     }

crates/engine/src/cmd/inquiry.rs

@@ -963,57 +963,6 @@ impl AreaM {
             AreaMode::Subtract => self.total - v,
         }
     }
-    /// Input while a height is pending: typed, or given by two points (their distance).
-    fn height_input(&mut self, s: &mut Session, i: Input) -> Step {
-        match (i, self.height_from) {
-            (Input::Point(p), None) => self.height_from = Some(p),
-            (Input::Point(p), Some(from)) => {
-                self.height_from = None;
-                return self.height(s, p.dist(from));
-            }
-            (Input::Text(t), None) => match crate::units::parse_distance(&t).filter(|v| v.is_finite()) {
-                Some(h) => return self.height(s, h),
-                None => s.echo("Requires a distance."),
-            },
-            (Input::Enter, None) => s.echo("Requires a height."),
-            (Input::Enter, Some(_)) => s.echo("Requires a second point."),
-            (Input::Text(_), Some(_)) => s.echo("Requires a point."),
-            _ => {}
-        }
-        Step::Continue
-    }
-
-    /// Input while the objects to measure are picked.
-    fn object_input(&mut self, s: &mut Session, i: Input) -> Step {
-        match i {
-            Input::Pick(hs) => {
-                for h in hs {
-                    match object_area(s, h) {
-                        Ok((a, per)) => {
-                            if self.measured(s, a, per) == Step::Done {
-                                return Step::Done;
-                            }
-                            // A single volume takes the first object with an area.
-                            if self.volume && self.mode == AreaMode::Single {
-                                break;
-                            }
-                        }
-                        Err(_) => s.echo("The selected object has no area."),
-                    }
-                }
-            }
-            Input::Enter => {
-                self.object = false;
-                if self.mode == AreaMode::Single {
-                    return Step::Done;
-                }
-            }
-            Input::Text(_) | Input::Keyword(_) => s.echo("*Invalid selection*"),
-            _ => {}
-        }
-        Step::Continue
-    }
-
     /// Measure the oldest pending area's volume with height `h`.
     fn height(&mut self, s: &mut Session, h: f64) -> Step {
         match self.pending.first().map(|a| a * h.abs()) {
@@ -1093,10 +1042,52 @@ impl Interactive for AreaM {
     }
     fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
         if !self.pending.is_empty() {
-            return Ok(self.height_input(s, i));
+            // A height is typed, or given by two points (their distance).
+            match (i, self.height_from) {
+                (Input::Point(p), None) => self.height_from = Some(p),
+                (Input::Point(p), Some(from)) => {
+                    self.height_from = None;
+                    return Ok(self.height(s, p.dist(from)));
+                }
+                (Input::Text(t), None) => match crate::units::parse_distance(&t).filter(|v| v.is_finite()) {
+                    Some(h) => return Ok(self.height(s, h)),
+                    None => s.echo("Requires a distance."),
+                },
+                (Input::Enter, None) => s.echo("Requires a height."),
+                (Input::Enter, Some(_)) => s.echo("Requires a second point."),
+                (Input::Text(_), Some(_)) => s.echo("Requires a point."),
+                _ => {}
+            }
+            return Ok(Step::Continue);
         }
         if self.object {
-            return Ok(self.object_input(s, i));
+            match i {
+                Input::Pick(hs) => {
+                    for h in hs {
+                        match object_area(s, h) {
+                            Ok((a, per)) => {
+                                if self.measured(s, a, per) == Step::Done {
+                                    return Ok(Step::Done);
+                                }
+                                // A single volume takes the first object with an area.
+                                if self.volume && self.mode == AreaMode::Single {
+                                    break;
+                                }
+                            }
+                            Err(_) => s.echo("The selected object has no area."),
+                        }
+                    }
+                }
+                Input::Enter => {
+                    self.object = false;
+                    if self.mode == AreaMode::Single {
+                        return Ok(Step::Done);
+                    }
+                }
+                Input::Text(_) | Input::Keyword(_) => s.echo("*Invalid selection*"),
+                _ => {}
+            }
+            return Ok(Step::Continue);
         }
         if self.length {
             if let Some(p) = length_input(&self.pts, i)? {

crates/engine/src/cmd/modify.rs

@@ -1296,128 +1296,6 @@ fn run_chamfer(s: &mut Session, p: &Value) -> Result<Value> {
 
 // ---------------- explode / array / order / break / join ----------------
 
-fn explode_block_ref(d: &cadcraft_doc::Drawing, e: &Entity, ins: &cadcraft_doc::Insert) -> Option<Vec<Entity>> {
-    if let Some(items) = super::array::explode_array(d, e) {
-        return Some(items);
-    }
-    let blk = d.block(&ins.block)?;
-    let m = ins.transform(blk.base.xy());
-    Some(
-        blk.entities
-            .iter()
-            .map(|be| {
-                let mut ne = (**be).clone();
-                ne.kind.transform(&m);
-                if ne.common.layer == "0" {
-                    ne.common.layer = e.common.layer.clone();
-                }
-                if ne.common.color == cadcraft_color::Color::ByBlock {
-                    ne.common.color = e.common.color;
-                }
-                ne
-            })
-            .collect(),
-    )
-}
-
-fn explode_mtext(e: &Entity, m: &cadcraft_doc::MText) -> Vec<Entity> {
-    cadcraft_fonts::plain_mtext(&m.contents)
-        .split('\n')
-        .enumerate()
-        .map(|(i, l)| {
-            let at = m.insert.xy() + Vec2::from_angle(m.rotation - std::f64::consts::FRAC_PI_2) * (m.height * (1.0 + 5.0 / 3.0 * i as f64));
-            Entity {
-                handle: Handle(0),
-                common: e.common.clone(),
-                kind: EntityKind::Text(cadcraft_doc::Text {
-                    insert: v3(at),
-                    align_pt: None,
-                    height: m.height,
-                    value: l.into(),
-                    rotation: m.rotation,
-                    width_factor: 1.0,
-                    oblique: 0.0,
-                    style: m.style.clone(),
-                    halign: Default::default(),
-                    valign: Default::default(),
-                }),
-            }
-        })
-        .collect()
-}
-
-/// The entities of a boundary's lines and arcs, on the object's layer and style.
-fn segment_entities(e: &Entity, segs: impl IntoIterator<Item = Segment>) -> Vec<Entity> {
-    segs.into_iter()
-        .map(|s| {
-            let k = match s {
-                Segment::Line(l) => line(l.a, l.b),
-                Segment::Arc { arc: a, .. } => arc(&a),
-            };
-            Entity { handle: Handle(0), common: e.common.clone(), kind: k }
-        })
-        .collect()
-}
-
-fn explode_dimension(d: &cadcraft_doc::Drawing, e: &Entity, dm: &cadcraft_doc::Dimension) -> Vec<Entity> {
-    // The dimension as drawn: its overrides, DIMSCALE (0 = the drawing's) and text font.
-    let style = d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides);
-    let g = cadcraft_render::dimension_in(d, dm);
-    let line_entity = |l: &Vec<Vec2>| {
-        if l.len() == 2 {
-            Some(Entity { handle: Handle(0), common: e.common.clone(), kind: line(*l.first()?, *l.get(1)?) })
-        } else {
-            Some(Entity { handle: Handle(0), common: e.common.clone(), kind: lwpoly(l.iter().map(|p| PolyVertex::new(*p)).collect(), false) })
-        }
-    };
-    // The text's marks (arc length symbol, DIMINSPECT frame) go after the text background.
-    let text_marks = &g.text_marks;
-    let marks = |want: bool| g.lines.iter().enumerate().filter(move |(i, _)| text_marks.contains(i) == want).map(|(_, l)| l);
-    let mut v: Vec<Entity> = marks(false).filter_map(&line_entity).collect();
-    for t in &g.fills {
-        if let [a, b, c] = t.as_slice() {
-            v.push(Entity {
-                handle: Handle(0),
-                common: e.common.clone(),
-                kind: EntityKind::Solid(cadcraft_doc::Solid { corners: [v3(*a), v3(*b), v3(*c), v3(*c)] }),
-            });
-        }
-    }
-    // DIMTFILL 2: the text background as a SOLID in DIMTFILLCLR, over the lines and
-    // arrowheads, under the text and its marks (SOLID corners go 1, 2, 4, 3).
-    if style.text_fill == 2
-        && let [p0, p1, p2, p3] = g.text_fill.as_slice()
-    {
-        let fill = style.text_fill_color;
-        let color = if fill == cadcraft_doc::color::Color::ByBlock { e.common.color } else { fill };
-        v.push(Entity {
-            handle: Handle(0),
-            common: cadcraft_doc::Common { color, ..e.common.clone() },
-            kind: EntityKind::Solid(cadcraft_doc::Solid { corners: [v3(*p0), v3(*p1), v3(*p3), v3(*p2)] }),
-        });
-    }
-    v.extend(marks(true).filter_map(&line_entity));
-    if !g.value.is_empty() {
-        v.push(Entity {
-            handle: Handle(0),
-            common: e.common.clone(),
-            kind: EntityKind::MText(cadcraft_doc::MText {
-                insert: v3(g.text_pos),
-                height: g.text_height,
-                width: 0.0,
-                attach: 5,
-                rotation: g.text_angle,
-                style: style.text_style.clone(),
-                contents: g.mtext_contents(),
-                line_spacing: 1.0,
-                line_spacing_exact: false,
-                columns: None,
-            }),
-        });
-    }
-    v
-}
-
 pub(crate) fn explode_kind(d: &cadcraft_doc::Drawing, e: &Entity) -> Option<Vec<Entity>> {
     // An annotative object explodes into plain objects as it draws at the current annotation scale.
     if cadcraft_doc::is_annotative(e) {
@@ -1431,9 +1309,42 @@ pub(crate) fn explode_kind(d: &cadcraft_doc::Drawing, e: &Entity) -> Option<Vec<
     match &e.kind {
         EntityKind::LwPolyline(p) => {
             let pl = Polyline { vertices: p.vertices.clone(), closed: p.closed };
-            Some(segment_entities(e, pl.segments()))
+            Some(
+                pl.segments()
+                    .into_iter()
+                    .map(|s| {
+                        let k = match s {
+                            Segment::Line(l) => line(l.a, l.b),
+                            Segment::Arc { arc: a, .. } => arc(&a),
+                        };
+                        Entity { handle: Handle(0), common: e.common.clone(), kind: k }
+                    })
+                    .collect(),
+            )
+        }
+        EntityKind::Insert(ins) => {
+            if let Some(items) = super::array::explode_array(d, e) {
+                return Some(items);
+            }
+            let blk = d.block(&ins.block)?;
+            let m = ins.transform(blk.base.xy());
+            Some(
+                blk.entities
+                    .iter()
+                    .map(|be| {
+                        let mut ne = (**be).clone();
+                        ne.kind.transform(&m);
+                        if ne.common.layer == "0" {
+                            ne.common.layer = e.common.layer.clone();
+                        }
+                        if ne.common.color == cadcraft_color::Color::ByBlock {
+                            ne.common.color = e.common.color;
+                        }
+                        ne
+                    })
+                    .collect(),
+            )
         }
-        EntityKind::Insert(ins) => explode_block_ref(d, e, ins),
         // A helix explodes into its spline (seen from above).
         EntityKind::Helix(h) => Some(vec![Entity { handle: Handle(0), common: e.common.clone(), kind: EntityKind::Spline(h.spline()) }]),
         EntityKind::Polyline3d(p) => Some(
@@ -1446,10 +1357,102 @@ pub(crate) fn explode_kind(d: &cadcraft_doc::Drawing, e: &Entity) -> Option<Vec<
                 .collect(),
         ),
         EntityKind::MLine(m) => Some(super::draw2::mline::explode(e, m)),
-        EntityKind::MText(m) => Some(explode_mtext(e, m)),
+        EntityKind::MText(m) => Some(
+            cadcraft_fonts::plain_mtext(&m.contents)
+                .split('\n')
+                .enumerate()
+                .map(|(i, l)| {
+                    let at = m.insert.xy() + Vec2::from_angle(m.rotation - std::f64::consts::FRAC_PI_2) * (m.height * (1.0 + 5.0 / 3.0 * i as f64));
+                    Entity {
+                        handle: Handle(0),
+                        common: e.common.clone(),
+                        kind: EntityKind::Text(cadcraft_doc::Text {
+                            insert: v3(at),
+                            align_pt: None,
+                            height: m.height,
+                            value: l.into(),
+                            rotation: m.rotation,
+                            width_factor: 1.0,
+                            oblique: 0.0,
+                            style: m.style.clone(),
+                            halign: Default::default(),
+                            valign: Default::default(),
+                        }),
+                    }
+                })
+                .collect(),
+        ),
         // A region explodes into its boundary's lines and arcs.
-        EntityKind::Region(r) => Some(segment_entities(e, r.segments())),
-        EntityKind::Dimension(dm) => Some(explode_dimension(d, e, dm)),
+        EntityKind::Region(r) => Some(
+            r.segments()
+                .into_iter()
+                .map(|s| {
+                    let k = match s {
+                        Segment::Line(l) => line(l.a, l.b),
+                        Segment::Arc { arc: a, .. } => arc(&a),
+                    };
+                    Entity { handle: Handle(0), common: e.common.clone(), kind: k }
+                })
+                .collect(),
+        ),
+        EntityKind::Dimension(dm) => {
+            // The dimension as drawn: its overrides, DIMSCALE (0 = the drawing's) and text font.
+            let style = d.dim_style(&dm.style).cloned().unwrap_or_default().with_overrides(&dm.overrides);
+            let g = cadcraft_render::dimension_in(d, dm);
+            let line_entity = |l: &Vec<Vec2>| {
+                if l.len() == 2 {
+                    Some(Entity { handle: Handle(0), common: e.common.clone(), kind: line(*l.first()?, *l.get(1)?) })
+                } else {
+                    Some(Entity { handle: Handle(0), common: e.common.clone(), kind: lwpoly(l.iter().map(|p| PolyVertex::new(*p)).collect(), false) })
+                }
+            };
+            // The text's marks (arc length symbol, DIMINSPECT frame) go after the text background.
+            let text_marks = &g.text_marks;
+            let marks = |want: bool| g.lines.iter().enumerate().filter(move |(i, _)| text_marks.contains(i) == want).map(|(_, l)| l);
+            let mut v: Vec<Entity> = marks(false).filter_map(&line_entity).collect();
+            for t in &g.fills {
+                if let [a, b, c] = t.as_slice() {
+                    v.push(Entity {
+                        handle: Handle(0),
+                        common: e.common.clone(),
+                        kind: EntityKind::Solid(cadcraft_doc::Solid { corners: [v3(*a), v3(*b), v3(*c), v3(*c)] }),
+                    });
+                }
+            }
+            // DIMTFILL 2: the text background as a SOLID in DIMTFILLCLR, over the lines and
+            // arrowheads, under the text and its marks (SOLID corners go 1, 2, 4, 3).
+            if style.text_fill == 2
+                && let [p0, p1, p2, p3] = g.text_fill.as_slice()
+            {
+                let fill = style.text_fill_color;
+                let color = if fill == cadcraft_doc::color::Color::ByBlock { e.common.color } else { fill };
+                v.push(Entity {
+                    handle: Handle(0),
+                    common: cadcraft_doc::Common { color, ..e.common.clone() },
+                    kind: EntityKind::Solid(cadcraft_doc::Solid { corners: [v3(*p0), v3(*p1), v3(*p3), v3(*p2)] }),
+                });
+            }
+            v.extend(marks(true).filter_map(&line_entity));
+            if !g.value.is_empty() {
+                v.push(Entity {
+                    handle: Handle(0),
+                    common: e.common.clone(),
+                    kind: EntityKind::MText(cadcraft_doc::MText {
+                        insert: v3(g.text_pos),
+                        height: g.text_height,
+                        width: 0.0,
+                        attach: 5,
+                        rotation: g.text_angle,
+                        style: style.text_style.clone(),
+                        contents: g.mtext_contents(),
+                        line_spacing: 1.0,
+                        line_spacing_exact: false,
+                        columns: None,
+                    }),
+                });
+            }
+            Some(v)
+        }
         EntityKind::Tolerance(t) => Some(super::tolerance::explode(d, e, t)),
         _ => None,
     }

crates/geom/src/fillet.rs

@@ -236,6 +236,46 @@ pub fn tangent_circles(c1: &TanCurve, c2: &TanCurve, r: f64, near: &[Vec2]) -> V
     if !(r.is_finite() && r >= 0.0) {
         return Vec::new();
     }
+    let Some(win) = search_window(c1, c2, near) else { return Vec::new() };
+    let size = win.width().max(win.height()).max(r).max(1e-9);
+    let win = win.expand(2.0 * r + 0.25 * size);
+    let tol = 1e-9 * size.max(1.0);
+    let (Some(r1), Some(r2)) = (c1.range(&win), c2.range(&win)) else { return Vec::new() };
+    let signs: &[(f64, f64)] = if r > 0.0 { &[(1.0, 1.0), (1.0, -1.0), (-1.0, 1.0), (-1.0, -1.0)] } else { &[(0.0, 0.0)] };
+    let mut out: Vec<CornerFit> = Vec::new();
+    let mut work = 16_000_000usize;
+    for (s1, s2) in signs {
+        let (d1, d2) = (s1 * r, s2 * r);
+        let (o1, o2) = (sample(c1, &r1, d1), sample(c2, &r2, d2));
+        let search = TanSearch { c1, r1: &r1, d1, c2, r2: &r2, d2, tol };
+        // Refine each pair before visiting the next: raw duplicate seeds in an early run must
+        // not consume all candidate slots. A separate request-wide budget bounds actual work.
+        for a in &o1 {
+            for b in &o2 {
+                if !refine_pair(&search, a, b, &mut work, &mut out) {
+                    return out;
+                }
+            }
+        }
+    }
+    out
+}
+
+/// The two curves of one tangent search for one sign choice: their ranges and offsets, and the
+/// tolerance.
+struct TanSearch<'a> {
+    c1: &'a TanCurve,
+    r1: &'a Range,
+    d1: f64,
+    c2: &'a TanCurve,
+    r2: &'a Range,
+    d2: f64,
+    tol: f64,
+}
+
+/// The window the tangent search looks in: the pick points and the extents of the curves that
+/// are not lines. `None` when it is empty or not finite.
+fn search_window(c1: &TanCurve, c2: &TanCurve, near: &[Vec2]) -> Option<Bounds2> {
     let mut win = Bounds2::from_points(near.iter().copied().filter(|p| p.is_finite()));
     for c in [c1, c2] {
         match c {
@@ -251,47 +291,34 @@ pub fn tangent_circles(c1: &TanCurve, c2: &TanCurve, r: f64, near: &[Vec2]) -> V
         }
     }
     if win.is_empty() || !(win.width().is_finite() && win.height().is_finite()) {
-        return Vec::new();
+        return None;
     }
-    let size = win.width().max(win.height()).max(r).max(1e-9);
-    let win = win.expand(2.0 * r + 0.25 * size);
-    let tol = 1e-9 * size.max(1.0);
-    let (Some(r1), Some(r2)) = (c1.range(&win), c2.range(&win)) else { return Vec::new() };
-    let signs: &[(f64, f64)] = if r > 0.0 { &[(1.0, 1.0), (1.0, -1.0), (-1.0, 1.0), (-1.0, -1.0)] } else { &[(0.0, 0.0)] };
-    let mut out: Vec<CornerFit> = Vec::new();
-    let mut work = 16_000_000usize;
-    for (s1, s2) in signs {
-        let (d1, d2) = (s1 * r, s2 * r);
-        let (o1, o2) = (sample(c1, &r1, d1), sample(c2, &r2, d2));
-        // Refine each pair before visiting the next: raw duplicate seeds in an early run must
-        // not consume all candidate slots. A separate request-wide budget bounds actual work.
-        for a in &o1 {
-            for b in &o2 {
-                let mut seeds = Vec::new();
-                crossings(a, b, &mut seeds, &mut work);
-                seeds.sort_by(|x, y| x.0.total_cmp(&y.0).then(x.1.total_cmp(&y.1)));
-                seeds.dedup_by(|x, y| (x.0 - y.0).abs() < 1e-9 && (x.1 - y.1).abs() < 1e-9);
-                for seed in seeds {
-                    // Newton refinement has a fixed iteration cap and several curve evaluations.
-                    let Some(left) = work.checked_sub(128) else { return out };
-                    work = left;
-                    let Some((t1, t2)) = refine(c1, &r1, d1, c2, &r2, d2, seed, tol) else { continue };
-                    let (Some(center), p1, p2) = (c1.offset(t1, d1), c1.point(t1), c2.point(t2)) else { continue };
-                    let near_dup = |f: &CornerFit| f.center.near(center, tol * 1e3) && f.p1.near(p1, tol * 1e3) && f.p2.near(p2, tol * 1e3);
-                    if !out.iter().any(near_dup) {
-                        out.push(CornerFit { t1, t2, p1, p2, center });
-                    }
-                    if out.len() >= MAX_SOLUTIONS {
-                        return out;
-                    }
-                }
-                if work == 0 {
-                    return out;
-                }
-            }
+    Some(win)
+}
+
+/// Refine the crossings of the samples `a` and `b` into circles, adding the distinct ones to
+/// `out`. `false` when the work budget or the solution cap ends the search.
+fn refine_pair(search: &TanSearch, a: &[(f64, Vec2)], b: &[(f64, Vec2)], work: &mut usize, out: &mut Vec<CornerFit>) -> bool {
+    let mut seeds = Vec::new();
+    crossings(a, b, &mut seeds, work);
+    seeds.sort_by(|x, y| x.0.total_cmp(&y.0).then(x.1.total_cmp(&y.1)));
+    seeds.dedup_by(|x, y| (x.0 - y.0).abs() < 1e-9 && (x.1 - y.1).abs() < 1e-9);
+    for seed in seeds {
+        // Newton refinement has a fixed iteration cap and several curve evaluations.
+        let Some(left) = work.checked_sub(128) else { return false };
+        *work = left;
+        let TanSearch { c1, r1, d1, c2, r2, d2, tol } = *search;
+        let Some((t1, t2)) = refine(c1, r1, d1, c2, r2, d2, seed, tol) else { continue };
+        let (Some(center), p1, p2) = (c1.offset(t1, d1), c1.point(t1), c2.point(t2)) else { continue };
+        let near_dup = |f: &CornerFit| f.center.near(center, tol * 1e3) && f.p1.near(p1, tol * 1e3) && f.p2.near(p2, tol * 1e3);
+        if !out.iter().any(near_dup) {
+            out.push(CornerFit { t1, t2, p1, p2, center });
+        }
+        if out.len() >= MAX_SOLUTIONS {
+            return false;
         }
     }
-    out
+    *work != 0
 }
 
 #[cfg(test)]

crates/render/src/hatch.rs

@@ -465,26 +465,6 @@ impl Family<'_> {
         self.origin + p.rotate(self.ang)
     }
 
-    /// The range of the lines swept, in this frame: the boundary's extent, cut to the view's
-    /// when there is one, and the view's x extent that spans are cut to. Spans are cut to the
-    /// view's extent only: they already lie within the boundary, and cutting them to its extent
-    /// too would move an end that sits on a boundary corner by a rounding error, so a view
-    /// covering the hatch would change its lines. `None` when the view misses the boundary.
-    fn lines_range(&self, bb: &Bounds2, view: Option<&Bounds2>) -> Option<(Vec2, Vec2, Option<(f64, f64)>)> {
-        let (mut lo, mut hi) = (bb.min, bb.max);
-        let mut span_cut = None;
-        if let Some(v) = view {
-            let vb = Bounds2::from_points(v.corners().iter().map(|p| self.to_local(*p)));
-            if vb.is_empty() || !vb.intersects(bb) {
-                return None;
-            }
-            lo = Vec2::new(lo.x.max(vb.min.x), lo.y.max(vb.min.y));
-            hi = Vec2::new(hi.x.min(vb.max.x), hi.y.min(vb.max.y));
-            span_cut = Some((vb.min.x, vb.max.x));
-        }
-        Some((lo, hi, span_cut))
-    }
-
     /// Intersect a pattern family with boundary loops, respecting view, output, cancellation, and shared dash-work limits.
     fn sweep(&self, loops: &[Vec<Vec2>], px: f64, view: Option<&Bounds2>, cancel: Option<&AtomicBool>, out: &mut Vec<Vec<Vec2>>, work: &mut u64) {
         let local: Vec<Vec<Vec2>> = loops.iter().map(|l| l.iter().map(|p| self.to_local(*p)).collect()).collect();
@@ -492,7 +472,21 @@ impl Family<'_> {
         if bb.is_empty() {
             return;
         }
-        let Some((lo, hi, span_cut)) = self.lines_range(&bb, view) else { return };
+        // The lines swept: the boundary's extent, cut to the view's (its corners in this frame)
+        // when there is one. Spans are cut to the view's extent only: they already lie within the
+        // boundary, and cutting them to its extent too would move an end that sits on a boundary
+        // corner by a rounding error, so a view covering the hatch would change its lines.
+        let (mut lo, mut hi) = (bb.min, bb.max);
+        let mut span_cut = None;
+        if let Some(v) = view {
+            let vb = Bounds2::from_points(v.corners().iter().map(|p| self.to_local(*p)));
+            if vb.is_empty() || !vb.intersects(&bb) {
+                return;
+            }
+            lo = Vec2::new(lo.x.max(vb.min.x), lo.y.max(vb.min.y));
+            hi = Vec2::new(hi.x.min(vb.max.x), hi.y.min(vb.max.y));
+            span_cut = Some((vb.min.x, vb.max.x));
+        }
         let shift_per_line = self.delta.rotate(-self.ang).x;
         let k0 = (lo.y / self.spacing).floor() as i64;
         let k1 = (hi.y / self.spacing).ceil() as i64;
@@ -510,7 +504,17 @@ impl Family<'_> {
                 return;
             }
             let y = k as f64 * self.spacing;
-            let xs = crossings(&local, y);
+            let mut xs: Vec<f64> = Vec::new();
+            for l in &local {
+                let n = l.len();
+                for i in 0..n {
+                    let (Some(a), Some(b)) = (l.get(i), l.get((i + 1) % n)) else { continue };
+                    if (a.y > y) != (b.y > y) {
+                        xs.push(a.x + (b.x - a.x) * (y - a.y) / (b.y - a.y));
+                    }
+                }
+            }
+            xs.sort_by(f64::total_cmp);
             let offset = shift_per_line * k as f64;
             for span in xs.chunks(2) {
                 let [x0, x1] = span else { continue };
@@ -561,22 +565,6 @@ impl Family<'_> {
     }
 }
 
-/// The x positions where the boundary loops cross the horizontal line at `y`, in order.
-fn crossings(local: &[Vec<Vec2>], y: f64) -> Vec<f64> {
-    let mut xs: Vec<f64> = Vec::new();
-    for l in local {
-        let n = l.len();
-        for i in 0..n {
-            let (Some(a), Some(b)) = (l.get(i), l.get((i + 1) % n)) else { continue };
-            if (a.y > y) != (b.y > y) {
-                xs.push(a.x + (b.x - a.x) * (y - a.y) / (b.y - a.y));
-            }
-        }
-    }
-    xs.sort_by(f64::total_cmp);
-    xs
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/ui-egui/src/canvas/compare.rs

@@ -4,8 +4,7 @@
 
 use std::sync::Arc;
 
-use cadcraft_engine::cmd::file::compare::Comparison;
-use cadcraft_engine::doc::{Drawing, Handle};
+use cadcraft_engine::doc::Handle;
 use cadcraft_render::DisplayList;
 use egui::{Rect, RichText, Stroke, vec2};
 use serde_json::json;
@@ -30,23 +29,6 @@ fn id() -> egui::Id {
     egui::Id::unique("cadcraft-compare-overlay")
 }
 
-/// The display lists of the differences for this frame: the stored ones when they still match
-/// `key`, otherwise rebuilt at zoom `scale` and stored.
-fn cache_for(ctx: &egui::Context, key: (u64, u64, usize, usize, i64), doc: &Drawing, c: &Comparison, scale: f64) -> Cache {
-    let mut cache: Cache = ctx.data_mut(|d| d.get_temp(id())).unwrap_or_default();
-    if cache.key != key || cache.ours.is_none() {
-        let opts = cadcraft_render::Options { tolerance: 0.5 / scale.max(1e-12), ..Default::default() };
-        let ours: Vec<Handle> = c.added.iter().copied().chain(c.changed.iter().map(|(a, _)| *a)).take(MAX_DRAWN).collect();
-        let theirs: Vec<Handle> = c.removed.iter().copied().chain(c.changed.iter().map(|(_, b)| *b)).take(MAX_DRAWN).collect();
-        let list = |d: &Drawing, hs: &[Handle]| {
-            Arc::new(cadcraft_render::build_entities(d, hs.iter().filter_map(|h| d.entity(*h)).map(|e| e.as_ref()), &opts))
-        };
-        cache = Cache { key, ours: Some(list(doc, &ours)), theirs: Some(list(&c.other, &theirs)) };
-        ctx.data_mut(|d| d.insert_temp(id(), cache.clone()));
-    }
-    cache
-}
-
 /// Draw the comparison over the canvas when it was made for the drawing and tab shown.
 pub(super) fn paint(app: &mut CadApp, ctx: &egui::Context, p: &egui::Painter, xf: &Xf, rect: Rect) {
     let t = Tokens::get();
@@ -56,7 +38,17 @@ pub(super) fn paint(app: &mut CadApp, ctx: &egui::Context, p: &egui::Painter, xf
     p.rect_filled(rect, 0.0, t.canvas.gamma_multiply(0.75));
     let band = xf.scale.max(1e-300).log2().round() as i64;
     let key = (st.uid, st.revision, Arc::as_ptr(&c.other) as usize, c.differences(), band);
-    let cache = cache_for(ctx, key, &st.doc, c, xf.scale);
+    let mut cache: Cache = ctx.data_mut(|d| d.get_temp(id())).unwrap_or_default();
+    if cache.key != key || cache.ours.is_none() {
+        let opts = cadcraft_render::Options { tolerance: 0.5 / xf.scale.max(1e-12), ..Default::default() };
+        let ours: Vec<Handle> = c.added.iter().copied().chain(c.changed.iter().map(|(a, _)| *a)).take(MAX_DRAWN).collect();
+        let theirs: Vec<Handle> = c.removed.iter().copied().chain(c.changed.iter().map(|(_, b)| *b)).take(MAX_DRAWN).collect();
+        let list = |d: &cadcraft_engine::doc::Drawing, hs: &[Handle]| {
+            Arc::new(cadcraft_render::build_entities(d, hs.iter().filter_map(|h| d.entity(*h)).map(|e| e.as_ref()), &opts))
+        };
+        cache = Cache { key, ours: Some(list(&st.doc, &ours)), theirs: Some(list(&c.other, &theirs)) };
+        ctx.data_mut(|d| d.insert_temp(id(), cache.clone()));
+    }
     for (list, color) in [(&cache.theirs, t.compare_other), (&cache.ours, t.compare_this)] {
         if let Some(l) = list {
             let all: Vec<usize> = (0..l.prims.len()).collect();

crates/ui-egui/src/menus.rs

@@ -172,7 +172,7 @@ fn run_ui_command_inner(app: &mut CadApp, id: &str, params: &Value) -> Option<Re
             let pick = app.services.pick_lisp.as_ref()?;
             let dir = app.ui.last_lisp_dir.clone().unwrap_or_default();
             let Some(path) = pick(&dir) else { return Some(Ok(Value::Null)) };
-            if let Some(dir) = std::path::Path::new(&path).parent().and_then(|p| p.to_str()).filter(|d| !d.is_empty()) {
+            if let Some(dir) = std::path::Path::new(&path).parent().and_then(std::path::Path::to_str).filter(|d| !d.is_empty()) {
                 app.ui.last_lisp_dir = Some(dir.to_string());
             }
             if let Err(e) = app.session.start("appload") {

crates/ui-egui/src/options/dialog.rs

@@ -217,15 +217,73 @@ fn display(app: &CadApp, ui: &mut egui::Ui, changes: &mut Map<String, Value>) {
 /// Files tab: save format and default version, new-drawing units, autosave interval and autosave file location; edits accumulate in `changes`.
 fn files(app: &CadApp, ui: &mut egui::Ui, changes: &mut Map<String, Value>) {
     grid(ui, "options_files", |ui| {
-        save_format_row(ui, app, changes);
+        ui.label(crate::tl!("Save new drawings as"));
+        ui.horizontal(|ui| {
+            for f in crate::SaveFormat::ALL {
+                let label = match f {
+                    crate::SaveFormat::Dxf => crate::tl!("DXF"),
+                    crate::SaveFormat::Dwg => crate::tl!("DWG"),
+                };
+                if ui.radio(app.ui.save_format == f, label).clicked() && app.ui.save_format != f {
+                    changes.insert("saveFormat".into(), json!(f.as_str()));
+                }
+            }
+        });
         ui.end_row();
-        save_version_row(ui, app, changes);
+
+        let version_caption = ui.label(crate::tl!("Default save version"));
+        let current = crate::SaveVersion::parse(&app.ui.save_version).unwrap_or_default();
+        let mut version = current;
+        let version_combo = egui::ComboBox::from_id_salt("options_save_version").selected_text(version.year()).show_ui(ui, |ui| {
+            for v in crate::SaveVersion::ALL {
+                ui.selectable_value(&mut version, v, v.year());
+            }
+        });
+        version_combo.response.labelled_by(version_caption.id);
+        if version != current {
+            changes.insert("saveVersion".into(), json!(version.year()));
+        }
         ui.end_row();
-        units_row(ui, app, changes);
+
+        ui.label(crate::tl!("Units of new drawings"));
+        ui.horizontal(|ui| {
+            let metric = app.session.settings.measureinit;
+            if ui.radio(!metric, crate::tl!("Imperial (inches)")).clicked() && metric {
+                changes.insert("MEASUREINIT".into(), json!(0));
+            }
+            if ui.radio(metric, crate::tl!("Metric (millimetres)")).clicked() && !metric {
+                changes.insert("MEASUREINIT".into(), json!(1));
+            }
+        });
         ui.end_row();
-        autosave_row(ui, changes);
+
+        let minutes_caption = ui.label(crate::tl!("Automatic save every"));
+        let mut minutes = cadcraft_engine::autosave::savetime();
+        let max = cadcraft_engine::autosave::MAX_SAVETIME;
+        if ui
+            .add(egui::DragValue::new(&mut minutes).range(0..=max).suffix(format!(" {}", crate::tl!("min"))))
+            .labelled_by(minutes_caption.id)
+            .changed()
+        {
+            changes.insert("SAVETIME".into(), json!(minutes));
+        }
         ui.end_row();
-        savefile_row(ui, changes);
+
+        let savefile_label = ui.label(crate::tl!("Automatic save file location"));
+        // Edited as text; the folder changes when the field loses focus.
+        let id = egui::Id::unique("cc_options_savefilepath");
+        let current = cadcraft_engine::autosave::savefilepath();
+        let mut path = ui.data(|d| d.get_temp::<String>(id)).unwrap_or_else(|| current.clone());
+        let r = ui.add(egui::TextEdit::singleline(&mut path).desired_width(330.0)).labelled_by(savefile_label.id);
+        if r.changed() {
+            ui.data_mut(|d| d.insert_temp(id, path.clone()));
+        }
+        if r.lost_focus() {
+            ui.data_mut(|d| d.remove::<String>(id));
+            if path.trim() != current {
+                changes.insert("SAVEFILEPATH".into(), json!(path.trim()));
+            }
+        }
         ui.end_row();
     });
     hint(ui, crate::tl!("New and the first drawing at startup use these units unless a default template is set (QNEWTEMPLATE)."));
@@ -233,76 +291,6 @@ fn files(app: &CadApp, ui: &mut egui::Ui, changes: &mut Map<String, Value>) {
     hint(ui, crate::tl!("Drawings with no file yet are saved in the default version. 0 minutes turns automatic save off."));
 }
 
-fn save_format_row(ui: &mut egui::Ui, app: &CadApp, changes: &mut Map<String, Value>) {
-    ui.label(crate::tl!("Save new drawings as"));
-    ui.horizontal(|ui| {
-        for f in crate::SaveFormat::ALL {
-            let label = match f {
-                crate::SaveFormat::Dxf => crate::tl!("DXF"),
-                crate::SaveFormat::Dwg => crate::tl!("DWG"),
-            };
-            if ui.radio(app.ui.save_format == f, label).clicked() && app.ui.save_format != f {
-                changes.insert("saveFormat".into(), json!(f.as_str()));
-            }
-        }
-    });
-}
-
-fn save_version_row(ui: &mut egui::Ui, app: &CadApp, changes: &mut Map<String, Value>) {
-    let version_caption = ui.label(crate::tl!("Default save version"));
-    let current = crate::SaveVersion::parse(&app.ui.save_version).unwrap_or_default();
-    let mut version = current;
-    let version_combo = egui::ComboBox::from_id_salt("options_save_version").selected_text(version.year()).show_ui(ui, |ui| {
-        for v in crate::SaveVersion::ALL {
-            ui.selectable_value(&mut version, v, v.year());
-        }
-    });
-    version_combo.response.labelled_by(version_caption.id);
-    if version != current {
-        changes.insert("saveVersion".into(), json!(version.year()));
-    }
-}
-
-fn units_row(ui: &mut egui::Ui, app: &CadApp, changes: &mut Map<String, Value>) {
-    ui.label(crate::tl!("Units of new drawings"));
-    ui.horizontal(|ui| {
-        let metric = app.session.settings.measureinit;
-        if ui.radio(!metric, crate::tl!("Imperial (inches)")).clicked() && metric {
-            changes.insert("MEASUREINIT".into(), json!(0));
-        }
-        if ui.radio(metric, crate::tl!("Metric (millimetres)")).clicked() && !metric {
-            changes.insert("MEASUREINIT".into(), json!(1));
-        }
-    });
-}
-
-fn autosave_row(ui: &mut egui::Ui, changes: &mut Map<String, Value>) {
-    let minutes_caption = ui.label(crate::tl!("Automatic save every"));
-    let mut minutes = cadcraft_engine::autosave::savetime();
-    let max = cadcraft_engine::autosave::MAX_SAVETIME;
-    if ui.add(egui::DragValue::new(&mut minutes).range(0..=max).suffix(format!(" {}", crate::tl!("min")))).labelled_by(minutes_caption.id).changed() {
-        changes.insert("SAVETIME".into(), json!(minutes));
-    }
-}
-
-fn savefile_row(ui: &mut egui::Ui, changes: &mut Map<String, Value>) {
-    let savefile_label = ui.label(crate::tl!("Automatic save file location"));
-    // Edited as text; the folder changes when the field loses focus.
-    let id = egui::Id::unique("cc_options_savefilepath");
-    let current = cadcraft_engine::autosave::savefilepath();
-    let mut path = ui.data(|d| d.get_temp::<String>(id)).unwrap_or_else(|| current.clone());
-    let r = ui.add(egui::TextEdit::singleline(&mut path).desired_width(330.0)).labelled_by(savefile_label.id);
-    if r.changed() {
-        ui.data_mut(|d| d.insert_temp(id, path.clone()));
-    }
-    if r.lost_focus() {
-        ui.data_mut(|d| d.remove::<String>(id));
-        if path.trim() != current {
-            changes.insert("SAVEFILEPATH".into(), json!(path.trim()));
-        }
-    }
-}
-
 /// Drafting tab: object-snap marker size and aperture previews plus the Drafting Settings entry; edits accumulate in `changes` and the entry may request a command through `start`.
 fn drafting(app: &CadApp, ui: &mut egui::Ui, changes: &mut Map<String, Value>, start: &mut Option<&'static str>) {
     let t = Tokens::get();