feat(dimension): complete diameter workflow

src/entities/dimension.rs

@@ -86,19 +86,24 @@ fn base_props(base: &DimensionBase) -> Vec<crate::scene::model::object::Property
 }
 
 fn properties(dim: &Dimension) -> Vec<PropSection> {
-    if let Dimension::Radius(radius) = dim {
+    let compact_radial = match dim {
+        Dimension::Radius(radius) => Some((&radius.base, radius.leader_length)),
+        Dimension::Diameter(diameter) => Some((&diameter.base, diameter.leader_length)),
+        _ => None,
+    };
+    if let Some((base, leader_length)) = compact_radial {
         return vec![PropSection {
             title: t!("Misc").into_owned(),
             props: vec![
                 Property {
                     label: t!("Dimension style").into_owned(),
                     field: "style_name",
-                    value: PropValue::PlainText(radius.base.style_name.clone()),
+                    value: PropValue::PlainText(base.style_name.clone()),
                 },
                 edit(
                     t!("Leader Length").as_ref(),
                     "leader_length",
-                    radius.leader_length,
+                    leader_length,
                 ),
             ],
         }];
@@ -1313,11 +1318,29 @@ impl Grippable for Dimension {
                 1 => apply_to_v3(&mut d.definition_point, &apply),
                 _ => {}
             },
-            Dimension::Diameter(d) => match grip_id {
-                0 => apply_to_v3(&mut d.angle_vertex, &apply),
-                1 => apply_to_v3(&mut d.definition_point, &apply),
-                _ => {}
-            },
+            Dimension::Diameter(d) => {
+                let center = d.center();
+                let radius = d.measurement() * 0.5;
+                let mut target = match grip_id {
+                    0 => d.angle_vertex,
+                    1 => d.definition_point,
+                    _ => center,
+                };
+                if grip_id <= 1 {
+                    apply_to_v3(&mut target, &apply);
+                    let offset = target - center;
+                    if offset.length_squared() > 1e-24 && radius > 1e-12 {
+                        let radial = offset.normalize() * radius;
+                        if grip_id == 0 {
+                            d.angle_vertex = center + radial;
+                            d.definition_point = center - radial;
+                        } else {
+                            d.definition_point = center + radial;
+                            d.angle_vertex = center - radial;
+                        }
+                    }
+                }
+            }
             Dimension::Angular2Ln(d) => match grip_id {
                 0 => apply_to_v3(&mut d.first_point, &apply),
                 1 => apply_to_v3(&mut d.second_point, &apply),
@@ -1700,9 +1723,18 @@ pub fn style_sections(
             inherited_name,
         )
     } else {
-        arrow_name(ov::DIMBLK1, s.dimblk1, &s.dimblk1_name)
+        let inherited = if matches!(dimension, Dimension::Diameter(_)) && !s.dimsah {
+            (s.dimblk, s.dimblk_name.as_str())
+        } else {
+            (s.dimblk1, s.dimblk1_name.as_str())
+        };
+        arrow_name(ov::DIMBLK1, inherited.0, inherited.1)
+    };
+    let arrow_2 = if matches!(dimension, Dimension::Diameter(_)) && !s.dimsah {
+        arrow_name(ov::DIMBLK2, s.dimblk, &s.dimblk_name)
+    } else {
+        arrow_name(ov::DIMBLK2, s.dimblk2, &s.dimblk2_name)
     };
-    let arrow_2 = arrow_name(ov::DIMBLK2, s.dimblk2, &s.dimblk2_name);
     for current in [&arrow_1, &arrow_2] {
         if !arrow_options.contains(current) {
             arrow_options.push(current.clone());
@@ -2379,7 +2411,7 @@ pub fn style_sections(
         },
     ];
 
-    if matches!(dimension, Dimension::Radius(_)) {
+    if matches!(dimension, Dimension::Radius(_) | Dimension::Diameter(_)) {
         let dimcen = real(ov::DIMCEN, s.dimcen);
         let center_type = if dimcen > 1e-12 {
             "Center marks"
@@ -2406,9 +2438,30 @@ pub fn style_sections(
                 "dim_ext_line_ext",
                 "dim_ext_line_offset",
             ];
+            const DIAMETER_LINE_FIELDS: &[&str] = &[
+                "dim_arrowhead_1",
+                "dim_arrowhead_2",
+                "dim_arrow_size",
+                "dim_line_lineweight",
+                "dim_ext_line_lineweight",
+                "dim_line_1",
+                "dim_line_2",
+                "dim_line_color",
+                "dim_linetype",
+                "dim_ext_linetype_1",
+                "dim_ext_line_1",
+                "dim_ext_line_color",
+                "dim_ext_line_ext",
+                "dim_ext_line_offset",
+            ];
+            let retained = if matches!(dimension, Dimension::Diameter(_)) {
+                DIAMETER_LINE_FIELDS
+            } else {
+                RADIUS_LINE_FIELDS
+            };
             lines
                 .props
-                .retain(|property| RADIUS_LINE_FIELDS.contains(&property.field));
+                .retain(|property| retained.contains(&property.field));
             lines.props.push(choice(
                 t!("Center mark").as_ref(),
                 "dim_center_type",
@@ -3049,6 +3102,32 @@ fn tessellate_dimension_inner(
                 defer_arrow_hatches,
             );
             (arrow.clone(), arrow)
+        } else if matches!(dim, Dimension::Diameter(_)) {
+            let data = &dim.base().common.extended_data;
+            let first = crate::entities::dim_override::handle(
+                data,
+                crate::entities::dim_override::DIMBLK1,
+            )
+            .unwrap_or(if dimsah { s.dimblk1 } else { s.dimblk });
+            let second = crate::entities::dim_override::handle(
+                data,
+                crate::entities::dim_override::DIMBLK2,
+            )
+            .unwrap_or(if dimsah { s.dimblk2 } else { s.dimblk });
+            (
+                arrow_from_block_with_deferred_hatch(
+                    document,
+                    first,
+                    dimasz,
+                    defer_arrow_hatches,
+                ),
+                arrow_from_block_with_deferred_hatch(
+                    document,
+                    second,
+                    dimasz,
+                    defer_arrow_hatches,
+                ),
+            )
         } else if dimsah {
             (
                 arrow_from_block_with_deferred_hatch(
@@ -3133,6 +3212,7 @@ fn tessellate_dimension_inner(
             dimtofl: style.map(|s| s.dimtofl).unwrap_or(false),
             text_position,
             horizontal_text,
+            text_movement: style.map(|s| s.dimtmove).unwrap_or(0),
             text_break,
         },
         SuppressFlags {
@@ -3642,7 +3722,15 @@ fn dimtmove_leader_endpoints(dim: &Dimension) -> Option<(Vec3, Vec3)> {
             (first + perp * off1 + second + perp * off2) * 0.5
         }
         Dimension::Radius(_) => return None,
-        Dimension::Diameter(d) => (lv(d.angle_vertex) + lv(d.definition_point)) * 0.5,
+        Dimension::Diameter(d) => {
+            let chord = lv(d.angle_vertex);
+            let far_chord = lv(d.definition_point);
+            if chord.distance_squared(lv(txt)) <= far_chord.distance_squared(lv(txt)) {
+                chord
+            } else {
+                far_chord
+            }
+        }
         Dimension::Angular2Ln(d) => lv(d.dimension_arc),
         Dimension::Angular3Pt(d) => lv(d.definition_point),
         _ => return None,
@@ -3716,6 +3804,7 @@ struct DimLineParams {
     dimtofl: bool,
     text_position: Vec3,
     horizontal_text: bool,
+    text_movement: i16,
     /// Text box (local centre, half-width, half-height) used to break the
     /// dimension line where the text sits on it, so a DIMTFILL background reads
     /// over the line. None when the text doesn't overlap the line.
@@ -3833,26 +3922,20 @@ fn dimension_geometry(
             }
         }
         Dimension::Diameter(d) => {
-            // angle_vertex is the circle centre and definition_point a point on
-            // the circle. The diameter line runs edge-to-edge THROUGH the centre
-            // (far edge → near edge), with arrows pointing inward at each edge.
-            let center = lv(d.angle_vertex);
-            let edge = lv(d.definition_point);
-            let far = center * 2.0 - edge;
-            add_segment(&mut g.dim_lines, far, edge);
-            append_arrow(&mut g, edge, normalized_or(far - edge, Vec3::X), arrow1);
-            append_arrow(&mut g, far, normalized_or(edge - far, Vec3::X), arrow2);
-            // Diameter leader: continue past the near edge toward the text.
-            if d.leader_length.abs() > 1e-9 {
-                let text = dimension_text_position(dim);
-                let leader_dir = normalized_or(text - edge, edge - far);
-                add_segment(
-                    &mut g.dim_lines,
-                    edge,
-                    edge + leader_dir * (d.leader_length as f32),
-                );
-            }
-            let radius = (edge - center).length();
+            let chord = lv(d.angle_vertex);
+            let far_chord = lv(d.definition_point);
+            append_diameter_dimension(
+                &mut g,
+                chord,
+                far_chord,
+                arrow1,
+                arrow2,
+                d.leader_length as f32,
+                params,
+                suppress,
+            );
+            let center = (chord + far_chord) * 0.5;
+            let radius = chord.distance(far_chord) * 0.5;
             append_center_mark(&mut g, center, params.dimcen, radius);
         }
         Dimension::Angular2Ln(d) => {
@@ -4137,6 +4220,107 @@ fn append_linear_dimension(
     }
 }
 
+fn append_diameter_dimension(
+    g: &mut DimGeom,
+    chord: Vec3,
+    far_chord: Vec3,
+    arrow1: &ArrowKind,
+    arrow2: &ArrowKind,
+    leader_length: f32,
+    params: DimLineParams,
+    suppress: SuppressFlags,
+) {
+    let axis = normalized_or(far_chord - chord, Vec3::X);
+    let diameter = chord.distance(far_chord);
+    if diameter <= 1e-6 {
+        return;
+    }
+
+    let arrows_outside = if params.ticks || params.arrow_len <= 1e-6 {
+        false
+    } else if diameter < 2.0 * params.arrow_len {
+        true
+    } else if diameter < params.text_width + 2.0 * params.arrow_len {
+        match params.dimatfit {
+            0 | 1 => true,
+            2 => false,
+            _ => params.text_width <= diameter,
+        }
+    } else {
+        false
+    };
+
+    let extension = if params.ticks { params.dimdle } else { 0.0 };
+    let first = chord - axis * extension;
+    let second = far_chord + axis * extension;
+    let line_length = first.distance(second);
+    let mut left_end = line_length * 0.5;
+    let mut right_start = left_end;
+    if let Some((text_center, half_width, half_height)) = params.text_break {
+        let along = (text_center - first).dot(axis);
+        if along > 0.0 && along < line_length {
+            left_end = along;
+            right_start = along;
+            let perpendicular = (text_center - (first + axis * along)).length();
+            if perpendicular < half_height
+                && along - half_width > 0.0
+                && along + half_width < line_length
+            {
+                left_end = along - half_width;
+                right_start = along + half_width;
+            }
+        }
+    }
+
+    let draw_inside_line = !arrows_outside || params.dimtofl;
+    if draw_inside_line && !suppress.dim1 && left_end > 1e-6 {
+        add_segment(&mut g.dim_lines, first, first + axis * left_end);
+    }
+    if draw_inside_line && !suppress.dim2 && line_length - right_start > 1e-6 {
+        add_segment(
+            &mut g.dim_lines,
+            first + axis * right_start,
+            second,
+        );
+    }
+    if arrows_outside && !params.dimsoxd {
+        let stub = params.arrow_len * 2.0;
+        if !suppress.dim1 {
+            add_segment(&mut g.dim_lines, chord - axis * stub, chord);
+        }
+        if !suppress.dim2 {
+            add_segment(&mut g.dim_lines, far_chord, far_chord + axis * stub);
+        }
+    }
+
+    if arrows_outside {
+        append_arrow(g, chord, -axis, arrow1);
+        append_arrow(g, far_chord, axis, arrow2);
+    } else {
+        append_arrow(g, chord, axis, arrow1);
+        append_arrow(g, far_chord, -axis, arrow2);
+    }
+
+    let text_along = (params.text_position - chord).dot(axis);
+    if params.text_movement == 0 {
+        let (tip, suppressed) = if params.text_position.distance_squared(chord)
+            <= params.text_position.distance_squared(far_chord)
+        {
+            (chord, suppress.dim1)
+        } else {
+            (far_chord, suppress.dim2)
+        };
+        if !suppressed && leader_length.abs() > 1e-6 {
+            let direction = normalized_or(params.text_position - tip, axis);
+            add_segment(&mut g.dim_lines, tip, tip + direction * leader_length.abs());
+        } else if text_along < 0.0 && !suppress.dim1 {
+            add_segment(&mut g.dim_lines, chord, params.text_position);
+        } else if text_along > diameter && !suppress.dim2 {
+            add_segment(&mut g.dim_lines, far_chord, params.text_position);
+        }
+    }
+}
+
 /// Draw a center mark for radius/diameter dimensions.
 ///   DIMCEN > 0 → small "+" of half-length |DIMCEN| at the centre.
 ///   DIMCEN < 0 → small "+" *plus* four line segments extending from the
@@ -4810,6 +4994,11 @@ fn dimension_text_is_outside(dim: &Dimension, style: Option<&DimStyle>) -> bool
             let length = (delta.x * delta.x + delta.y * delta.y).sqrt().max(1e-12);
             (d.first_point, d.second_point, delta / length)
         }
+        Dimension::Diameter(d) => {
+            let delta = d.definition_point - d.angle_vertex;
+            let length = (delta.x * delta.x + delta.y * delta.y).sqrt().max(1e-12);
+            (d.angle_vertex, d.definition_point, delta / length)
+        }
         _ => return false,
     };
     let first_axis = first.x * axis.x + first.y * axis.y;
@@ -4856,6 +5045,8 @@ fn dimension_text_natural_rotation(dim: &Dimension) -> f64 {
             .unwrap_or(0.0),
         Dimension::Radius(d) => (d.definition_point.y - d.angle_vertex.y)
             .atan2(d.definition_point.x - d.angle_vertex.x),
+        Dimension::Diameter(d) => (d.definition_point.y - d.angle_vertex.y)
+            .atan2(d.definition_point.x - d.angle_vertex.x),
         _ => 0.0,
     };
     // Clamp to (-π/2, π/2] so text never appears upside-down.
@@ -5459,26 +5650,6 @@ fn swap_decimal_sep(s: &str, dsep_code: i16) -> String {
     s.replace('.', &ch.to_string())
 }
 
-fn dimension_text_position(dim: &Dimension) -> Vec3 {
-    let lv = |v| vec3_local(v);
-    let base = dim.base();
-    let pos = lv(base.text_middle_point);
-    if pos.length_squared() > 1e-8 {
-        return pos;
-    }
-    match dim {
-        Dimension::Aligned(d) => (lv(d.first_point) + lv(d.second_point)) * 0.5,
-        Dimension::Linear(d) => (lv(d.first_point) + lv(d.second_point)) * 0.5,
-        Dimension::Radius(d) => (lv(d.angle_vertex) + lv(d.definition_point)) * 0.5,
-        Dimension::Diameter(d) => (lv(d.angle_vertex) + lv(d.definition_point)) * 0.5,
-        Dimension::Angular2Ln(d) => lv(d.dimension_arc),
-        Dimension::Angular3Pt(d) => lv(d.definition_point),
-        Dimension::Ordinate(d) => lv(d.leader_endpoint),
-        Dimension::Arc(d) => lv(d.definition_point),
-        Dimension::LargeRadial(d) => lv(d.jog_point),
-    }
-}
-
 fn vec3_local(v: Vector3) -> Vec3 {
     Vec3::new(v.x as f32, v.y as f32, v.z as f32)
 }
@@ -5697,19 +5868,28 @@ fn dimension_text_pos_f64(
             }
             Vector3::new(x, y, d.definition_point.z)
         }
+        Dimension::Diameter(d) => {
+            let dx = d.definition_point.x - d.angle_vertex.x;
+            let dy = d.definition_point.y - d.angle_vertex.y;
+            let len = (dx * dx + dy * dy).sqrt().max(1e-12);
+            text_on_dim_line(
+                d.angle_vertex,
+                d.definition_point,
+                d.angle_vertex,
+                dx / len,
+                dy / len,
+                dimjust,
+                perp_off,
+                text_w,
+                arrow,
+                dimtix,
+                dimatfit,
+                dimtad,
+            )
+        }
         _ => {
-            // Non-linear (radius / diameter / angular / ordinate): lift the
-            // natural mid point straight up by the style offset. A user-dragged
-            // text point is already returned by the `use_saved` gate above, so
-            // we must NOT short-circuit on a merely-nonzero text_middle_point
-            // here — that would ignore the style placement for auto-placed dims
-            // and make a re-style a no-op. (#181)
+            // Auto-placed text follows the style offset.
             let mid = match dim {
-                Dimension::Diameter(d) => Vector3::new(
-                    (d.angle_vertex.x + d.definition_point.x) * 0.5,
-                    (d.angle_vertex.y + d.definition_point.y) * 0.5,
-                    (d.angle_vertex.z + d.definition_point.z) * 0.5,
-                ),
                 Dimension::Angular2Ln(d) => d.dimension_arc,
                 Dimension::Angular3Pt(d) => d.definition_point,
                 Dimension::Ordinate(d) => d.leader_endpoint,