From 6505b2781805c81af082a67b84db879f3735d730 Mon Sep 17 00:00:00 2001 From: ramox81 <184937705+ramox81@users.noreply.github.com> Date: Mon, 14 Sep 2026 11:55:08 +0300 Subject: [PATCH] fix(annotate): align annotation ribbon workflows --- src/app/command_driver.rs | 618 +++++++++++++++++++++- src/app/commands/display.rs | 178 ++++++- src/app/commands/mod.rs | 1 + src/command.rs | 15 + src/entities/dimension.rs | 101 +++- src/modules/annotate/aligned_dim.rs | 17 +- src/modules/annotate/angular_dim.rs | 4 +- src/modules/annotate/annotation_scale.rs | 50 ++ src/modules/annotate/arc_length_dim.rs | 4 +- src/modules/annotate/diameter_dim.rs | 4 +- src/modules/annotate/dimbreak.rs | 208 ++++++-- src/modules/annotate/dimedit.rs | 148 ++++-- src/modules/annotate/dimjogline.rs | 238 ++++++--- src/modules/annotate/dimspace.rs | 128 ++++- src/modules/annotate/dimtedit.rs | 279 +++++++--- src/modules/annotate/jogged_radius_dim.rs | 4 +- src/modules/annotate/leader_cmd.rs | 114 +++- src/modules/annotate/linear_dim.rs | 24 +- src/modules/annotate/mleader_cmd.rs | 2 + src/modules/annotate/mod.rs | 57 +- src/modules/annotate/mtext.rs | 2 + src/modules/annotate/ordinate_dim.rs | 4 +- src/modules/annotate/radius_dim.rs | 4 +- src/modules/draw/draw/revcloud.rs | 13 +- src/modules/draw/draw/wipeout.rs | 11 +- src/scene/annotative.rs | 38 ++ 26 files changed, 1921 insertions(+), 345 deletions(-) create mode 100644 src/modules/annotate/annotation_scale.rs diff --git a/src/app/command_driver.rs b/src/app/command_driver.rs index 01e70881d..016bdfe4b 100644 --- a/src/app/command_driver.rs +++ b/src/app/command_driver.rs @@ -2777,6 +2777,33 @@ impl OpenCADStudio { } self.refresh_properties(); } + CmdResult::UpdateEntityAndFinish { handle, entity } => { + if self.reject_locked_edit(i, handle) { + self.tabs[i].active_cmd = None; + return Task::none(); + } + let label = self.history_label_from_active_cmd(i, "EDIT"); + self.push_undo_snapshot(i, label); + let is_dimension = matches!(entity, acadrust::EntityType::Dimension(_)); + if let Some(current) = self.tabs[i].scene.document.get_entity_mut(handle) { + *current = entity; + if is_dimension { + self.tabs[i].scene.invalidate_dim_block_recorded(handle); + } + self.tabs[i] + .scene + .bump_entities(&[(handle, crate::scene::ChangeKind::Modified)]); + self.tabs[i].dirty = true; + } else { + self.command_line.push_error( + crate::t!("The selected object is no longer available.").as_ref(), + ); + } + self.tabs[i].scene.clear_preview_wire(); + self.tabs[i].active_cmd = None; + self.tabs[i].snap_result = None; + self.refresh_properties(); + } CmdResult::AddSketchConstraint { kind, refs, driving_param, label } => { if let Err(message) = self.tabs[i] .scene @@ -2948,36 +2975,111 @@ impl OpenCADStudio { if new_entities.len() == 1 { if let acadrust::EntityType::XLine(ref xl) = new_entities[0] { let layer = xl.common.layer.clone(); - if layer.starts_with("__DIMBREAK__") - || layer.starts_with("__DIMBREAK_AUTO__") - { - // DIMBREAK needs a break-gap field on the dimension - // model (not yet present) to store and render the gap. - // Report honestly rather than claiming success while - // changing nothing. (#181 / DIM-020) - self.command_line - .push_info(crate::t!("DIMBREAK: not yet implemented — nothing changed.").as_ref()); + if layer.starts_with("__DIMBREAK_") { + self.push_undo_snapshot(i, "DIMBREAK"); + let result = apply_dimbreak(&mut self.tabs[i].scene, &layer); + if result.changed.is_empty() { + self.command_line.push_info(&result.message); + self.tabs[i].active_cmd = None; + self.tabs[i].snap_result = None; + return Task::none(); + } + for handle in &result.changed { + self.tabs[i].scene.invalidate_dim_block_recorded(*handle); + } + let changes: Vec<_> = result + .changed + .iter() + .copied() + .map(|handle| (handle, crate::scene::ChangeKind::Modified)) + .collect(); + self.tabs[i].scene.bump_entities(&changes); + self.tabs[i].dirty = true; + self.command_line.push_output(&result.message); self.tabs[i].active_cmd = None; self.tabs[i].snap_result = None; return Task::none(); } if layer.starts_with("__DIMSPACE__") { + self.push_undo_snapshot(i, "DIMSPACE"); if let Some(encoded) = layer.strip_prefix("__DIMSPACE__") { apply_dimspace(&mut self.tabs[i].scene, encoded); } - self.push_undo_snapshot(i, "DIMSPACE"); self.command_line.push_output(crate::t!("DIMSPACE Spacing adjusted.").as_ref()); self.tabs[i].dirty = true; self.tabs[i].active_cmd = None; self.tabs[i].snap_result = None; return Task::none(); } - if layer.starts_with("__DIMJOG__") { - // DIMJOGLINE needs a jog-point field on the dimension - // model (not yet present) to store and render the jog. - // Report honestly rather than faking success. (DIM-019) - self.command_line - .push_info(crate::t!("DIMJOGLINE: not yet implemented — nothing changed.").as_ref()); + if layer.starts_with("__DIMJOG__") + || layer.starts_with("__DIMJOG_REMOVE__") + { + let remove = layer.starts_with("__DIMJOG_REMOVE__"); + let point = layer + .strip_prefix("__DIMJOG__") + .and_then(|encoded| encoded.split_once('|')) + .and_then(|(_, coordinates)| { + let mut values = coordinates + .split(',') + .filter_map(|value| value.parse::().ok()); + Some(acadrust::types::Vector3::new( + values.next()?, + values.next()?, + values.next()?, + )) + }); + let valid = matches!( + self.tabs[i].scene.document.get_entity(handle), + Some(acadrust::EntityType::Dimension( + acadrust::entities::Dimension::Linear(_) + | acadrust::entities::Dimension::Aligned(_) + )) + ); + if !valid || (!remove && point.is_none()) { + self.command_line.push_error( + crate::t!("DIMJOGLINE: select a linear or aligned dimension.") + .as_ref(), + ); + self.tabs[i].active_cmd = None; + self.tabs[i].snap_result = None; + return Task::none(); + } + self.push_undo_snapshot(i, "DIMJOGLINE"); + if remove { + crate::scene::view::dispatch::set_entity_xdata( + &mut self.tabs[i].scene.document, + handle, + "ACAD_DSTYLE_DIMJAG_POSITION", + None, + ); + } else if let Some(point) = point { + use acadrust::xdata::XDataValue; + crate::scene::view::dispatch::set_entity_xdata( + &mut self.tabs[i].scene.document, + handle, + "ACAD_DSTYLE_DIMJAG_POSITION", + Some(vec![ + XDataValue::Integer16(387), + XDataValue::Integer16(3), + XDataValue::Integer16(389), + XDataValue::Point3D(point), + ]), + ); + } + self.tabs[i].scene.invalidate_dim_block_recorded(handle); + self.tabs[i].scene.bump_entities(&[( + handle, + crate::scene::ChangeKind::Modified, + )]); + self.tabs[i].dirty = true; + self.command_line.push_output( + if remove { + crate::t!("DIMJOGLINE: jog removed.") + } else { + crate::t!("DIMJOGLINE: jog added.") + } + .as_ref(), + ); self.tabs[i].active_cmd = None; self.tabs[i].snap_result = None; return Task::none(); @@ -5621,6 +5723,72 @@ impl OpenCADStudio { self.tabs[i].snap_result = None; self.tabs[i].scene.clear_preview_wire(); } + CmdResult::EditDimensions { + mut handles, + operation, + } => { + handles.retain(|handle| { + !self.tabs[i].scene.is_layer_locked(*handle) + && matches!( + self.tabs[i].scene.document.get_entity(*handle), + Some(acadrust::EntityType::Dimension(_)) + ) + }); + if handles.is_empty() { + self.command_line + .push_error(crate::t!("DIMEDIT: no editable dimensions were selected.").as_ref()); + } else { + self.push_undo_snapshot(i, "DIMEDIT"); + for handle in &handles { + if let Some(acadrust::EntityType::Dimension(dimension)) = + self.tabs[i].scene.document.get_entity_mut(*handle) + { + use crate::command::DimensionEditOperation as Operation; + match &operation { + Operation::Home => { + let base = dimension.base_mut(); + base.text_middle_point = acadrust::types::Vector3::ZERO; + base.insertion_point = acadrust::types::Vector3::ZERO; + base.text_user_positioned = false; + base.text_rotation = 0.0; + } + Operation::NewText(text) => { + dimension.base_mut().set_text_override( + (!text.is_empty()).then_some(text.clone()), + ); + } + Operation::Rotate(degrees) => { + dimension.base_mut().text_rotation = degrees.to_radians(); + } + Operation::Oblique(degrees) => match dimension { + acadrust::entities::Dimension::Linear(value) => { + value.ext_line_rotation = degrees.to_radians(); + } + acadrust::entities::Dimension::Aligned(value) => { + value.ext_line_rotation = degrees.to_radians(); + } + _ => {} + }, + } + } + self.tabs[i].scene.invalidate_dim_block_recorded(*handle); + } + let changes: Vec<_> = handles + .iter() + .copied() + .map(|handle| (handle, crate::scene::ChangeKind::Modified)) + .collect(); + self.tabs[i].scene.bump_entities(&changes); + self.tabs[i].dirty = true; + self.command_line.push_output( + crate::tf!("DIMEDIT: updated {} dimension(s).", handles.len()).as_ref(), + ); + } + self.tabs[i].active_cmd = None; + self.tabs[i].snap_result = None; + self.tabs[i].scene.clear_preview_wire(); + self.restore_pre_cmd_tangent(); + } CmdResult::DdeditEntity { handle, new_text } => { if self.reject_locked_edit(i, handle) { self.tabs[i].active_cmd = None; @@ -6176,6 +6344,382 @@ fn remap_object( // ── DIMSPACE helper ─────────────────────────────────────────────────────────── +struct DimBreakResult { + changed: Vec, + message: String, +} + +#[derive(Clone, Copy)] +enum DimBreakOperation { + Auto, + Object(Handle), + Manual(glam::DVec3, glam::DVec3), + Remove, +} + +fn parse_dim_break_handles(encoded: &str) -> Vec { + encoded + .split(';') + .filter_map(|value| value.parse::().ok()) + .map(Handle::from) + .filter(|handle| !handle.is_null()) + .collect() +} + +fn parse_dim_break_point(encoded: &str) -> Option { + let mut values = encoded.split(',').map(str::parse::); + Some(glam::DVec3::new( + values.next()?.ok()?, + values.next()?.ok()?, + values.next()?.ok()?, + )) +} + +fn parse_dim_break(encoded: &str) -> Option<(Vec, DimBreakOperation)> { + if let Some(handles) = encoded.strip_prefix("__DIMBREAK_AUTO__") { + return Some((parse_dim_break_handles(handles), DimBreakOperation::Auto)); + } + if let Some(handles) = encoded.strip_prefix("__DIMBREAK_REMOVE__") { + return Some((parse_dim_break_handles(handles), DimBreakOperation::Remove)); + } + if let Some(rest) = encoded.strip_prefix("__DIMBREAK_OBJECT__") { + let (handles, crossing) = rest.split_once('|')?; + return Some(( + parse_dim_break_handles(handles), + DimBreakOperation::Object(Handle::from(crossing.parse::().ok()?)), + )); + } + if let Some(rest) = encoded.strip_prefix("__DIMBREAK_MANUAL__") { + let mut parts = rest.split('|'); + let handles = parse_dim_break_handles(parts.next()?); + let first = parse_dim_break_point(parts.next()?)?; + let second = parse_dim_break_point(parts.next()?)?; + return Some((handles, DimBreakOperation::Manual(first, second))); + } + None +} + +fn wire_segments( + models: &[crate::scene::model::wire_model::WireModel], +) -> Vec<(glam::DVec3, glam::DVec3)> { + let mut output = Vec::new(); + for model in models { + for run in model.points.split(|point| !point[0].is_finite()) { + for pair in run.windows(2) { + let first = glam::DVec3::new( + pair[0][0] as f64, + pair[0][1] as f64, + pair[0][2] as f64, + ); + let second = glam::DVec3::new( + pair[1][0] as f64, + pair[1][1] as f64, + pair[1][2] as f64, + ); + if first.is_finite() + && second.is_finite() + && first.distance_squared(second) > 1.0e-18 + { + output.push((first, second)); + } + } + } + } + output +} + +fn segment_intersection_xy( + first: (glam::DVec3, glam::DVec3), + second: (glam::DVec3, glam::DVec3), +) -> Option<(glam::DVec3, glam::DVec3)> { + let p = first.0; + let r = first.1 - first.0; + let q = second.0; + let s = second.1 - second.0; + let cross = |a: glam::DVec3, b: glam::DVec3| a.x * b.y - a.y * b.x; + let denominator = cross(r, s); + if denominator.abs() <= 1.0e-12 { + return None; + } + let qp = q - p; + let t = cross(qp, s) / denominator; + let u = cross(qp, r) / denominator; + if !(-1.0e-9..=1.0 + 1.0e-9).contains(&t) + || !(-1.0e-9..=1.0 + 1.0e-9).contains(&u) + { + return None; + } + let direction = r.normalize_or_zero(); + if direction.length_squared() <= 1.0e-18 { + return None; + } + let center = p + r * t.clamp(0.0, 1.0); + let half_gap = 0.25_f64.min(first.0.distance(first.1) * 0.2); + Some(( + center - direction * half_gap, + center + direction * half_gap, + )) +} + +fn break_object_handle(document: &acadrust::CadDocument, dimension: Handle) -> Option { + document.objects.iter().find_map(|(handle, object)| { + let acadrust::objects::ObjectType::DataObject(object) = object else { + return None; + }; + let acadrust::objects::DataObjectData::BreakData(data) = &object.data else { + return None; + }; + (data.dimension_reference == dimension).then_some(*handle) + }) +} + +fn remove_dimension_break_data(document: &mut acadrust::CadDocument, dimension: Handle) -> bool { + let handles: Vec<_> = document + .objects + .iter() + .filter_map(|(handle, object)| match object { + acadrust::objects::ObjectType::DataObject(object) => match &object.data { + acadrust::objects::DataObjectData::BreakData(data) + if data.dimension_reference == dimension => Some(*handle), + _ => None, + }, + _ => None, + }) + .collect(); + if handles.is_empty() { + return false; + } + for handle in &handles { + document.objects.remove(handle); + } + if let Some(dictionary_handle) = document.extension_dictionary_handle(dimension) { + if let Some(acadrust::objects::ObjectType::Dictionary(dictionary)) = + document.objects.get_mut(&dictionary_handle) + { + dictionary.entries.retain(|(name, handle)| { + !name.eq_ignore_ascii_case("ACAD_BREAKDATA") && !handles.contains(handle) + }); + dictionary + .hard_owner_entries + .retain(|name| !name.eq_ignore_ascii_case("ACAD_BREAKDATA")); + } + } + true +} + +fn write_dimension_break_data( + document: &mut acadrust::CadDocument, + dimension: Handle, + reserved_reference: Handle, + references: Vec, +) -> bool { + use acadrust::objects::{BreakData, DataObject, DataObjectData, Dictionary, ObjectType}; + + if references.is_empty() { + return remove_dimension_break_data(document, dimension); + } + if let Some(handle) = break_object_handle(document, dimension) { + if let Some(ObjectType::DataObject(object)) = document.objects.get_mut(&handle) { + object.data = DataObjectData::BreakData(BreakData { + version: 0, + dimension_reference: dimension, + reserved_reference, + point_references: references, + }); + return true; + } + } + + let dictionary_handle = match document.extension_dictionary_handle(dimension) { + Some(handle) => handle, + None => { + let handle = document.allocate_handle(); + let mut dictionary = Dictionary::new(); + dictionary.handle = handle; + dictionary.owner = dimension; + dictionary.hard_owner = true; + document + .objects + .insert(handle, ObjectType::Dictionary(dictionary)); + if let Some(entity) = document.get_entity_mut(dimension) { + entity.common_mut().xdictionary_handle = Some(handle); + } + handle + } + }; + + let object_handle = document.allocate_handle(); + let mut object = DataObject::new(DataObjectData::BreakData(BreakData { + version: 0, + dimension_reference: dimension, + reserved_reference, + point_references: references, + })); + object.handle = object_handle; + object.owner = dictionary_handle; + document + .objects + .insert(object_handle, ObjectType::DataObject(object)); + if let Some(ObjectType::Dictionary(dictionary)) = + document.objects.get_mut(&dictionary_handle) + { + dictionary + .entries + .retain(|(name, _)| !name.eq_ignore_ascii_case("ACAD_BREAKDATA")); + dictionary.add_entry("ACAD_BREAKDATA", object_handle); + dictionary.set_entry_hard_owner("ACAD_BREAKDATA", true); + } + true +} + +fn break_reference( + identifier: i32, + reference_type: i32, + first: glam::DVec3, + second: glam::DVec3, +) -> acadrust::objects::BreakPointReference { + acadrust::objects::BreakPointReference { + version: 0, + reserved: 0, + reference_type, + flags: 0, + identifier, + first_point: acadrust::types::Vector3::new(first.x, first.y, first.z), + second_point: acadrust::types::Vector3::new(second.x, second.y, second.z), + trailing_version: 0, + } +} + +fn apply_dimbreak(scene: &mut crate::scene::Scene, encoded: &str) -> DimBreakResult { + let Some((requested, operation)) = parse_dim_break(encoded) else { + return DimBreakResult { + changed: Vec::new(), + message: crate::t!("DIMBREAK: invalid operation data.").into_owned(), + }; + }; + let dimensions: Vec<_> = requested + .into_iter() + .filter(|handle| { + matches!( + scene.document.get_entity(*handle), + Some(acadrust::EntityType::Dimension(_)) + ) && scene.locked_layer_name(*handle).is_none() + }) + .collect(); + if dimensions.is_empty() { + return DimBreakResult { + changed: Vec::new(), + message: crate::t!("DIMBREAK: no editable dimensions were selected.").into_owned(), + }; + } + + if matches!(operation, DimBreakOperation::Remove) { + let changed: Vec<_> = dimensions + .into_iter() + .filter(|handle| remove_dimension_break_data(&mut scene.document, *handle)) + .collect(); + return DimBreakResult { + message: crate::tf!("DIMBREAK: removed breaks from {} dimension(s).", changed.len()) + .into_owned(), + changed, + }; + } + + let crossing_handles: Vec = match operation { + DimBreakOperation::Object(handle) => vec![handle], + DimBreakOperation::Auto => scene + .document + .entities() + .map(|entity| entity.common().handle) + .filter(|handle| { + !dimensions.contains(handle) && scene.entity_belongs_to_active_space(*handle) + }) + .collect(), + DimBreakOperation::Manual(_, _) | DimBreakOperation::Remove => Vec::new(), + }; + let crossing_segments: Vec<_> = crossing_handles + .iter() + .flat_map(|handle| wire_segments(&scene.wire_models_for(&[*handle]))) + .collect(); + + let mut pending = Vec::new(); + for dimension in &dimensions { + let existing: Vec<_> = break_object_handle(&scene.document, *dimension) + .and_then(|handle| scene.document.objects.get(&handle)) + .and_then(|object| match object { + acadrust::objects::ObjectType::DataObject(object) => match &object.data { + acadrust::objects::DataObjectData::BreakData(data) => { + Some(data.point_references.clone()) + } + _ => None, + }, + _ => None, + }) + .unwrap_or_default(); + let mut references = if matches!(operation, DimBreakOperation::Manual(_, _)) { + existing + } else { + existing + .into_iter() + .filter(|reference| reference.reference_type == 2) + .collect() + }; + match operation { + DimBreakOperation::Manual(first, second) => { + references.push(break_reference(references.len() as i32, 2, first, second)); + } + DimBreakOperation::Auto | DimBreakOperation::Object(_) => { + let dimension_segments = wire_segments(&scene.wire_models_for(&[*dimension])); + let mut intersections = Vec::new(); + for dim_segment in &dimension_segments { + for crossing_segment in &crossing_segments { + if let Some(points) = + segment_intersection_xy(*dim_segment, *crossing_segment) + { + let center = (points.0 + points.1) * 0.5; + if intersections.iter().all( + |(first, second): &(glam::DVec3, glam::DVec3)| { + center.distance_squared((*first + *second) * 0.5) > 1.0e-8 + }, + ) { + intersections.push(points); + } + } + } + } + let start = references.len() as i32; + references.extend(intersections.into_iter().enumerate().map( + |(index, points)| { + break_reference(start + index as i32, 1, points.0, points.1) + }, + )); + } + DimBreakOperation::Remove => {} + } + pending.push((*dimension, references)); + } + + let reserved = match operation { + DimBreakOperation::Object(handle) => handle, + _ => Handle::NULL, + }; + let changed: Vec<_> = pending + .into_iter() + .filter_map(|(dimension, references)| { + write_dimension_break_data(&mut scene.document, dimension, reserved, references) + .then_some(dimension) + }) + .collect(); + DimBreakResult { + message: if changed.is_empty() { + crate::t!("DIMBREAK: no intersections were found.").into_owned() + } else { + crate::tf!("DIMBREAK: updated {} dimension(s).", changed.len()).into_owned() + }, + changed, + } +} + /// Parse `base_val,h1;h2;...;hN,spacing` and adjust parallel dimension positions. fn apply_dimspace(scene: &mut crate::scene::Scene, encoded: &str) { // Format: ",

;

;...;," @@ -6188,7 +6732,11 @@ fn apply_dimspace(scene: &mut crate::scene::Scene, encoded: &str) { .split(';') .filter_map(|s| s.parse::().ok()) .collect(); - let spacing: f64 = parts[2].parse().unwrap_or(0.0); + let requested_spacing = if parts[2].eq_ignore_ascii_case("AUTO") { + None + } else { + parts[2].parse::().ok() + }; use acadrust::entities::Dimension; let base_h = acadrust::Handle::from(base_val); @@ -6196,25 +6744,27 @@ fn apply_dimspace(scene: &mut crate::scene::Scene, encoded: &str) { // dim line's perpendicular coordinate. Spacing steps each parallel dim along // this perp IN THE DRAWING PLANE — offsetting Z had no effect on the dim // line, which is computed from def·perp with perp.z = 0. (#181 / DIM-021) - let (perp, base_coord) = match scene.document.get_entity(base_h) { - Some(acadrust::EntityType::Dimension(Dimension::Linear(d))) => { + let (perp, base_coord, auto_spacing) = match scene.document.get_entity(base_h) { + Some(acadrust::EntityType::Dimension(dimension @ Dimension::Linear(d))) => { let (s, c) = d.rotation.sin_cos(); let perp = (-s, c); let dp = d.definition_point; - (perp, dp.x * perp.0 + dp.y * perp.1) + let spacing = dimension_auto_spacing(&scene.document, dimension, scene.creation_annotation_multiplier()); + (perp, dp.x * perp.0 + dp.y * perp.1, spacing) } - Some(acadrust::EntityType::Dimension(Dimension::Aligned(d))) => { + Some(acadrust::EntityType::Dimension(dimension @ Dimension::Aligned(d))) => { let dx = d.second_point.x - d.first_point.x; let dy = d.second_point.y - d.first_point.y; let len = (dx * dx + dy * dy).sqrt().max(1e-12); let perp = (-dy / len, dx / len); let dp = d.definition_point; - (perp, dp.x * perp.0 + dp.y * perp.1) + let spacing = dimension_auto_spacing(&scene.document, dimension, scene.creation_annotation_multiplier()); + (perp, dp.x * perp.0 + dp.y * perp.1, spacing) } _ => return, }; - let effective_spacing = if spacing <= 0.0 { 10.0 } else { spacing }; + let effective_spacing = requested_spacing.unwrap_or(auto_spacing); let mut changes = Vec::new(); for (idx, &hv) in other_vals.iter().enumerate() { let h = acadrust::Handle::from(hv); @@ -6256,6 +6806,28 @@ fn apply_dimspace(scene: &mut crate::scene::Scene, encoded: &str) { } } +fn dimension_auto_spacing( + document: &acadrust::CadDocument, + dimension: &acadrust::entities::Dimension, + annotation_multiplier: f64, +) -> f64 { + let style = document + .dim_styles + .iter() + .find(|style| style.name.eq_ignore_ascii_case(&dimension.base().style_name)) + .map(|style| crate::entities::dimension::resolved_dimension_style(style, dimension, document)); + style + .map(|style| { + let scale = if style.dimscale > 1.0e-9 { + style.dimscale + } else { + annotation_multiplier.max(1.0e-9) + }; + (style.dimdli.abs() * scale).max(1.0e-6) + }) + .unwrap_or(3.75) +} + fn apply_mleader_align( scene: &mut crate::scene::Scene, handles: &[acadrust::Handle], diff --git a/src/app/commands/display.rs b/src/app/commands/display.rs index 91cdaca00..7fed79462 100644 --- a/src/app/commands/display.rs +++ b/src/app/commands/display.rs @@ -1041,55 +1041,110 @@ impl OpenCADStudio { return Some(Task::done(Message::PlotDialogOpen)); } - // ── Recognized commands whose full implementation is pending ───────── - // These verbs are surfaced by the ribbon / menus but their feature is - // still being built. Acknowledge them with an honest status so the - // button responds instead of reporting an unknown command; each is - // replaced by its real handler as the feature lands. - // OBJECTSCALE ADD — add the active scale representation to every - // selected object that supports per-scale context data. - "OBJECTSCALE ADD" => { - let handles: Vec = self.tabs[i] + // Add or remove the current representation on the selected + // annotative objects. With no preselection, gather one through the + // regular selection engine before applying the action. + action @ ("OBJECTSCALE ADD" | "OBJECTSCALE DELETE") => { + let selected: Vec = self.tabs[i] .scene .selected_entities() .iter() .map(|(h, _)| *h) .filter(|handle| !self.tabs[i].scene.is_layer_locked(*handle)) .collect(); - if handles.is_empty() { + if selected.is_empty() { + let action = if action.ends_with("ADD") { + "OBJECTSCALE ADD" + } else { + "OBJECTSCALE DELETE" + }; + let command = crate::modules::annotate::annotation_scale::AnnotationScaleSelectionCommand::new( + "OBJECTSCALE", + action, + ); self.command_line - .push_error(crate::t!("OBJECTSCALE: select objects first.").as_ref()); + .push_info(&crate::command::CadCommand::prompt(&command)); + self.tabs[i].active_cmd = Some(Box::new(command)); return Some(Task::none()); } - self.push_undo_snapshot(i, "OBJECTSCALE"); let Some(scale) = self.tabs[i].scene.creation_annotation_scale_handle() else { self.command_line .push_error(crate::t!("OBJECTSCALE: the active annotation scale is unavailable.").as_ref()); return Some(Task::none()); }; - let mut n = 0usize; - for h in &handles { - if crate::scene::annotative::create_annotation_context( - &mut self.tabs[i].scene.document, - *h, - scale, - ) { - crate::scene::annotative::set_entity_annotative( - &mut self.tabs[i].scene.document, - *h, - true, + + let adding = action.ends_with("ADD"); + let handles: Vec<_> = selected + .into_iter() + .filter(|handle| { + let memberships = crate::scene::annotative::object_scale_memberships( + &self.tabs[i].scene.document, + *handle, ); - n += 1; + let member = memberships.iter().any(|(_, current)| *current == scale); + if adding { + !member + && self.tabs[i] + .scene + .document + .get_entity(*handle) + .is_some_and(crate::scene::annotative::supports_annotation_context) + } else { + member + } + }) + .collect(); + if handles.is_empty() { + self.command_line.push_info( + if adding { + crate::t!("OBJECTSCALE: the selected objects already have the current scale, or do not support annotation scales.") + } else { + crate::t!("OBJECTSCALE: the selected objects do not have the current scale.") + } + .as_ref(), + ); + return Some(Task::none()); + } + + self.push_undo_snapshot(i, "OBJECTSCALE"); + let mut changed = Vec::new(); + for handle in handles { + let ok = if adding { + let created = crate::scene::annotative::create_annotation_context( + &mut self.tabs[i].scene.document, + handle, + scale, + ); + if created { + crate::scene::annotative::set_entity_annotative( + &mut self.tabs[i].scene.document, + handle, + true, + ); + } + created + } else { + crate::scene::annotative::remove_annotation_context_for_scale( + &mut self.tabs[i].scene.document, + handle, + scale, + ) + }; + if ok { + changed.push(handle); } } - let changes: Vec<_> = handles - .into_iter() + let changes: Vec<_> = changed + .iter() + .copied() .map(|handle| (handle, crate::scene::ChangeKind::Modified)) .collect(); self.tabs[i].scene.bump_entities(&changes); self.tabs[i].dirty = true; self.command_line.push_output(crate::tf!( - "OBJECTSCALE: added the active scale to {n} object(s)." + "OBJECTSCALE: {} the current scale on {} object(s).", + if adding { "added" } else { "removed" }, + changed.len() ).as_ref()); return Some(Task::none()); } @@ -1459,6 +1514,75 @@ impl OpenCADStudio { return Some(Task::done(Message::AnnoObjectScaleOpen)); } + // Reset every alternate scale representation to the position of + // the representation visible at the current annotation scale. + "ANNORESET" => { + let handles: Vec = self.tabs[i] + .scene + .selected_entities() + .iter() + .map(|(handle, _)| *handle) + .filter(|handle| !self.tabs[i].scene.is_layer_locked(*handle)) + .collect(); + if handles.is_empty() { + let command = crate::modules::annotate::annotation_scale::AnnotationScaleSelectionCommand::new( + "ANNORESET", + "ANNORESET", + ); + self.command_line + .push_info(&crate::command::CadCommand::prompt(&command)); + self.tabs[i].active_cmd = Some(Box::new(command)); + return Some(Task::none()); + } + let scale = self.tabs[i].scene.creation_annotation_scale_handle(); + let candidates: Vec<_> = handles + .into_iter() + .filter(|handle| { + crate::scene::annotative::object_scale_memberships( + &self.tabs[i].scene.document, + *handle, + ) + .len() + > 1 + }) + .collect(); + if candidates.is_empty() { + self.command_line.push_info( + crate::t!("ANNORESET: no selected object has alternate scale representations.") + .as_ref(), + ); + return Some(Task::none()); + } + self.push_undo_snapshot(i, "ANNORESET"); + let mut changed = Vec::new(); + for handle in candidates { + if crate::scene::annotative::reset_annotation_context_positions( + &mut self.tabs[i].scene.document, + handle, + scale, + ) { + changed.push(handle); + } + } + if !changed.is_empty() { + let changes: Vec<_> = changed + .iter() + .copied() + .map(|handle| (handle, crate::scene::ChangeKind::Modified)) + .collect(); + self.tabs[i].scene.bump_entities(&changes); + self.tabs[i].dirty = true; + } + self.command_line.push_output( + crate::tf!( + "ANNORESET: synchronized {} object(s) from the current scale.", + changed.len() + ) + .as_ref(), + ); + return Some(Task::none()); + } + // DATALINK — create a persistent linked table. "DATALINK" => { use crate::command::ValuePromptCommand; diff --git a/src/app/commands/mod.rs b/src/app/commands/mod.rs index c847a1d03..ed8ffb5ef 100644 --- a/src/app/commands/mod.rs +++ b/src/app/commands/mod.rs @@ -400,6 +400,7 @@ inventory::submit!(crate::command::CommandRegistration { "ANNOUPDATE", "SCALELISTEDIT", "OBJECTSCALE", + "ANNORESET", // Import CSV into a table + LandXML survey points. "DATALINK", "DATALINKUPDATE", diff --git a/src/command.rs b/src/command.rs index a6761926a..b806cce34 100644 --- a/src/command.rs +++ b/src/command.rs @@ -1314,6 +1314,14 @@ impl Default for LoftOptions { } } +#[derive(Clone, Debug)] +pub enum DimensionEditOperation { + Home, + NewText(String), + Rotate(f64), + Oblique(f64), +} + /// Returned by every `CadCommand` method to tell main.rs what to do. #[allow(dead_code)] pub enum CmdResult { @@ -1412,6 +1420,8 @@ pub enum CmdResult { BatchCopy(Vec, Vec), /// Erase `handle` and replace with new entities; command stays active. ReplaceEntity(Handle, Vec), + /// Update one entity in place, preserve its handle, and end the command. + UpdateEntityAndFinish { handle: Handle, entity: EntityType }, /// Replace / delete multiple entities and add new ones; command ends. /// Each pair: (handle_to_erase, replacement_entities) — empty vec = delete only. ReplaceMany(Vec<(Handle, Vec)>, Vec), @@ -1592,6 +1602,11 @@ pub enum CmdResult { QuickPrint(Vec), /// Replace the text content of a Text/MText entity in-place. DdeditEntity { handle: Handle, new_text: String }, + /// Apply one DIMEDIT operation to every selected dimension. + EditDimensions { + handles: Vec, + operation: DimensionEditOperation, + }, /// Open the in-place editor (plain box or rich MText editor, per type) for /// a text-bearing entity picked by a command such as DDEDIT. EditTextEntity { handle: Handle }, diff --git a/src/entities/dimension.rs b/src/entities/dimension.rs index c2f704fa2..1d6278cf9 100644 --- a/src/entities/dimension.rs +++ b/src/entities/dimension.rs @@ -3450,6 +3450,93 @@ fn apply_dimension_breaks( *lines = output; } +fn dimension_jog_point(dimension: &Dimension) -> Option { + if !matches!(dimension, Dimension::Linear(_) | Dimension::Aligned(_)) { + return None; + } + dimension + .base() + .common + .extended_data + .get_record("ACAD_DSTYLE_DIMJAG_POSITION") + .and_then(|record| { + record.values.iter().rev().find_map(|value| match value { + acadrust::xdata::XDataValue::Point3D(point) => Some(vec3_local(*point)), + _ => None, + }) + }) +} + +fn apply_dimension_jog(lines: &mut Vec<[f32; 3]>, requested: Vec3, size: f32, angle: f32) { + if lines.len() < 2 { + return; + } + let mut best: Option<(usize, Vec3, f32)> = None; + for (index, segment) in lines.windows(2).enumerate() { + if segment[0][0].is_nan() || segment[1][0].is_nan() { + continue; + } + let first = Vec3::from_array(segment[0]); + let second = Vec3::from_array(segment[1]); + let delta = second - first; + let length_squared = delta.length_squared(); + if length_squared <= 1.0e-12 { + continue; + } + let parameter = ((requested - first).dot(delta) / length_squared).clamp(0.0, 1.0); + let point = first + delta * parameter; + let distance = point.distance_squared(requested); + if best.is_none_or(|(_, _, current)| distance < current) { + best = Some((index, point, distance)); + } + } + let Some((target, center, _)) = best else { + return; + }; + let first = Vec3::from_array(lines[target]); + let second = Vec3::from_array(lines[target + 1]); + let Some(direction) = (second - first).try_normalize() else { + return; + }; + let perpendicular = Vec3::new(-direction.y, direction.x, 0.0); + let half = size.max(1.0e-3).min(first.distance(second) * 0.2); + let amplitude = (half * (angle * 0.5).tan().abs()).clamp(half * 0.35, half * 1.5); + let jog_start = center - direction * half; + let jog_end = center + direction * half; + let jog = [ + jog_start, + center - direction * half * 0.25 + perpendicular * amplitude, + center + direction * half * 0.25 - perpendicular * amplitude, + jog_end, + ]; + + let mut output = Vec::with_capacity(lines.len() + 4); + output.extend_from_slice(&lines[..target]); + if !output.is_empty() && !output.last().is_some_and(|point| point[0].is_nan()) { + output.push([f32::NAN; 3]); + } + if first.distance_squared(jog_start) > 1.0e-12 { + output.push(first.to_array()); + output.push(jog_start.to_array()); + output.push([f32::NAN; 3]); + } + output.extend(jog.into_iter().map(|point| point.to_array())); + if jog_end.distance_squared(second) > 1.0e-12 { + output.push([f32::NAN; 3]); + output.push(jog_end.to_array()); + output.push(second.to_array()); + } + if target + 2 < lines.len() { + if !output.last().is_some_and(|point| point[0].is_nan()) + && !lines[target + 2][0].is_nan() + { + output.push([f32::NAN; 3]); + } + output.extend_from_slice(&lines[target + 2..]); + } + *lines = output; +} + pub trait DimensionTess { fn tessellate( &self, @@ -3783,12 +3870,19 @@ fn tessellate_dimension_inner( // DIMUPT governs interactive creation-time text placement; saved // geometry already carries the resulting position. let _ = s.dimupt; - let _ = (s.dimarcsym, s.dimjogang); + let _ = s.dimarcsym; // DIMUNIT is the obsolete pre-R2000 linear unit format; DIMLUNIT // supersedes it. Read but not honoured. let _ = s.dimunit; } + if let Some(point) = dimension_jog_point(dim) { + let jog_angle = style + .map(|style| style.dimjogang as f32) + .unwrap_or(std::f32::consts::FRAC_PI_4); + apply_dimension_jog(&mut geom.dim_lines, point, dim_txt as f32 * 0.6, jog_angle); + } apply_dimension_breaks(document, handle, &mut geom.dim_lines); + apply_dimension_breaks(document, handle, &mut geom.ext_lines); // Dimension entity fields that the render path doesn't yet use but are // preserved on save: // - base.insertion_point: legacy anchor reference; render uses @@ -7229,6 +7323,11 @@ pub(crate) fn baked_large_radial_geometry( dimension.base().common.handle, &mut geometry.dim_lines, ); + apply_dimension_breaks( + document, + dimension.base().common.handle, + &mut geometry.ext_lines, + ); Some(geometry) } diff --git a/src/modules/annotate/aligned_dim.rs b/src/modules/annotate/aligned_dim.rs index d6eb177a3..872a00232 100644 --- a/src/modules/annotate/aligned_dim.rs +++ b/src/modules/annotate/aligned_dim.rs @@ -6,7 +6,7 @@ use acadrust::EntityType; use glam::DVec3; use crate::command::{ - CadCommand, CmdResult, DimensionAssociationInput, InputKind, WorkingPlane, + CadCommand, CmdOption, CmdResult, DimensionAssociationInput, InputKind, WorkingPlane, }; use crate::modules::{IconKind, ModuleEvent, ToolDef}; use crate::scene::model::wire_model::WireModel; @@ -164,11 +164,24 @@ impl CadCommand for AlignedDimensionCommand { fn input_kind(&self) -> InputKind { if self.awaiting_text { InputKind::FreeText - } else { + } else if self.awaiting_angle { InputKind::SingleToken + } else { + InputKind::Point } } + fn options(&self) -> Vec { + if !matches!(self.step, Step::DimLine { .. }) || self.awaiting_text || self.awaiting_angle { + return Vec::new(); + } + vec![ + CmdOption::new("MText", "MTEXT"), + CmdOption::new("Text", "TEXT"), + CmdOption::new("Angle", "ANGLE"), + ] + } + fn point_step_accepts_keywords(&self) -> bool { // While entering the override text or angle it is a value, not a point // step. diff --git a/src/modules/annotate/angular_dim.rs b/src/modules/annotate/angular_dim.rs index ae736581b..b5d3bf417 100644 --- a/src/modules/annotate/angular_dim.rs +++ b/src/modules/annotate/angular_dim.rs @@ -489,8 +489,10 @@ impl CadCommand for AngularDimensionCommand { fn input_kind(&self) -> InputKind { if self.awaiting_text { InputKind::FreeText - } else { + } else if self.awaiting_angle || self.awaiting_quadrant { InputKind::SingleToken + } else { + InputKind::Point } } diff --git a/src/modules/annotate/annotation_scale.rs b/src/modules/annotate/annotation_scale.rs new file mode 100644 index 000000000..40fc8a748 --- /dev/null +++ b/src/modules/annotate/annotation_scale.rs @@ -0,0 +1,50 @@ +use acadrust::Handle; +use glam::DVec3; + +use crate::command::{CadCommand, CmdResult}; + +/// Selection front-end used by the annotation-scale ribbon actions. The +/// action itself runs only after the normal selection engine completes, so +/// window/crossing selection, removal, Escape and Previous all keep their +/// usual behavior. +pub struct AnnotationScaleSelectionCommand { + name: &'static str, + action: &'static str, +} + +impl AnnotationScaleSelectionCommand { + pub fn new(name: &'static str, action: &'static str) -> Self { + Self { name, action } + } +} + +impl CadCommand for AnnotationScaleSelectionCommand { + fn name(&self) -> &'static str { + self.name + } + + fn prompt(&self) -> String { + crate::tf!("{} Select annotative objects:", self.name).into_owned() + } + + fn is_selection_gathering(&self) -> bool { + true + } + + fn on_selection_complete(&mut self, handles: Vec) -> CmdResult { + if handles.is_empty() { + CmdResult::Cancel + } else { + CmdResult::Relaunch(self.action.to_string(), handles) + } + } + + fn on_point(&mut self, _point: DVec3) -> CmdResult { + CmdResult::NeedPoint + } + + fn on_enter(&mut self) -> CmdResult { + CmdResult::Cancel + } +} + diff --git a/src/modules/annotate/arc_length_dim.rs b/src/modules/annotate/arc_length_dim.rs index 2e7b3ef5f..4797c70c9 100644 --- a/src/modules/annotate/arc_length_dim.rs +++ b/src/modules/annotate/arc_length_dim.rs @@ -353,8 +353,10 @@ impl CadCommand for ArcLengthDimensionCommand { fn input_kind(&self) -> InputKind { if self.awaiting_text { InputKind::FreeText - } else { + } else if self.awaiting_angle { InputKind::SingleToken + } else { + InputKind::Point } } diff --git a/src/modules/annotate/diameter_dim.rs b/src/modules/annotate/diameter_dim.rs index de60b43b4..1f712ff5e 100644 --- a/src/modules/annotate/diameter_dim.rs +++ b/src/modules/annotate/diameter_dim.rs @@ -139,8 +139,10 @@ impl CadCommand for DiameterDimensionCommand { fn input_kind(&self) -> InputKind { if self.awaiting_text { InputKind::FreeText - } else { + } else if self.awaiting_angle { InputKind::SingleToken + } else { + InputKind::Point } } diff --git a/src/modules/annotate/dimbreak.rs b/src/modules/annotate/dimbreak.rs index e37cdbe4e..49011dea6 100644 --- a/src/modules/annotate/dimbreak.rs +++ b/src/modules/annotate/dimbreak.rs @@ -1,18 +1,9 @@ -// DIMBREAK command — insert a break in a dimension/extension line where -// another object crosses it. -// -// Simplified workflow: -// 1. Select the dimension to break -// 2. Select the object that crosses it (or Enter for AUTO mode on all crossings) -// -// Because breaking a dimension line requires deep geometric intersection logic -// that depends on the renderer, this implementation records the target handles -// and emits a ReplaceEntity sentinel that commands.rs intercepts to apply the break. +// DIMBREAK — create automatic, object-driven or manual gaps in dimensions. -use acadrust::Handle; +use acadrust::{EntityType, Handle}; use glam::DVec3; -use crate::command::{CadCommand, CmdResult}; +use crate::command::{CadCommand, CmdOption, CmdResult, InputKind}; use crate::modules::{IconKind, ModuleEvent, ToolDef}; use crate::t; @@ -28,20 +19,54 @@ pub fn tool() -> ToolDef { } enum Step { - PickDim, - PickCrossing { dim_handle: Handle }, + PickDimension, + PickDimensions(Vec), + PickCrossing(Vec), + ManualFirst(Vec), + ManualSecond(Vec, DVec3), } pub struct DimBreakCommand { step: Step, + picked_entity: Option, } impl DimBreakCommand { pub fn new() -> Self { Self { - step: Step::PickDim, + step: Step::PickDimension, + picked_entity: None, } } + + fn marker(layer: String, primary: Handle) -> CmdResult { + use acadrust::entities::XLine; + let mut marker = XLine::default(); + marker.common.layer = layer; + CmdResult::ReplaceEntity(primary, vec![EntityType::XLine(marker)]) + } + + fn handles(handles: &[Handle]) -> String { + handles + .iter() + .map(|handle| handle.value().to_string()) + .collect::>() + .join(";") + } + + fn automatic(handles: &[Handle]) -> CmdResult { + Self::marker( + format!("__DIMBREAK_AUTO__{}", Self::handles(handles)), + handles[0], + ) + } + + fn remove(handles: &[Handle]) -> CmdResult { + Self::marker( + format!("__DIMBREAK_REMOVE__{}", Self::handles(handles)), + handles[0], + ) + } } impl CadCommand for DimBreakCommand { @@ -51,54 +76,151 @@ impl CadCommand for DimBreakCommand { fn prompt(&self) -> String { match &self.step { - Step::PickDim => t!("DIMBREAK Select dimension to break:").into_owned(), - Step::PickCrossing { .. } => { - t!("DIMBREAK Select object to break at, or Enter for Auto:").into_owned() + Step::PickDimension => { + t!("DIMBREAK Select dimension to add/remove break or [Multiple]:").into_owned() + } + Step::PickDimensions(handles) => crate::tf!( + "DIMBREAK Select dimensions ({} selected, press Enter when done):", + handles.len() + ) + .into_owned(), + Step::PickCrossing(_) => t!( + "DIMBREAK Select object to break dimension or [Auto/Manual/Remove] :" + ) + .into_owned(), + Step::ManualFirst(_) => t!("DIMBREAK Specify first break point:").into_owned(), + Step::ManualSecond(_, _) => { + t!("DIMBREAK Specify second break point:").into_owned() } } } + fn options(&self) -> Vec { + match self.step { + Step::PickDimension => vec![CmdOption::new("Multiple", "MULTIPLE")], + Step::PickCrossing(_) => vec![ + CmdOption::new("Auto", "AUTO"), + CmdOption::new("Manual", "MANUAL"), + CmdOption::new("Remove", "REMOVE"), + ], + _ => Vec::new(), + } + } + + fn input_kind(&self) -> InputKind { + InputKind::Point + } + + fn point_step_accepts_keywords(&self) -> bool { + matches!(self.step, Step::PickDimension | Step::PickCrossing(_)) + } + fn needs_entity_pick(&self) -> bool { - true + matches!( + self.step, + Step::PickDimension | Step::PickDimensions(_) | Step::PickCrossing(_) + ) } - fn on_entity_pick(&mut self, handle: Handle, _pt: DVec3) -> CmdResult { + fn inject_before_entity_pick(&self) -> bool { + matches!(self.step, Step::PickDimension | Step::PickDimensions(_)) + } + + fn inject_picked_entity(&mut self, entity: EntityType) { + self.picked_entity = Some(entity); + } + + fn on_entity_pick(&mut self, handle: Handle, _point: DVec3) -> CmdResult { if handle.is_null() { return CmdResult::NeedPoint; } - match &self.step { - Step::PickDim => { - self.step = Step::PickCrossing { dim_handle: handle }; + match &mut self.step { + Step::PickDimension => { + if !matches!(self.picked_entity.take(), Some(EntityType::Dimension(_))) { + return CmdResult::ReportError( + t!("DIMBREAK: select a dimension.").into_owned(), + ); + } + self.step = Step::PickCrossing(vec![handle]); CmdResult::NeedPoint } - Step::PickCrossing { dim_handle } => { - let dim_h = *dim_handle; - // Emit sentinel: the actual break logic is in commands.rs - use acadrust::entities::XLine; - let mut xl = XLine::default(); - xl.common.layer = format!("__DIMBREAK__{},{}", dim_h.value(), handle.value()); - CmdResult::ReplaceEntity(dim_h, vec![acadrust::EntityType::XLine(xl)]) + Step::PickDimensions(handles) => { + if !matches!(self.picked_entity.take(), Some(EntityType::Dimension(_))) { + return CmdResult::ReportError( + t!("DIMBREAK: select a dimension.").into_owned(), + ); + } + if !handles.contains(&handle) { + handles.push(handle); + } + CmdResult::NeedPoint } + Step::PickCrossing(handles) => Self::marker( + format!( + "__DIMBREAK_OBJECT__{}|{}", + Self::handles(handles), + handle.value() + ), + handles[0], + ), + Step::ManualFirst(_) | Step::ManualSecond(_, _) => CmdResult::NeedPoint, } } - fn on_point(&mut self, _pt: DVec3) -> CmdResult { - CmdResult::NeedPoint + fn on_text_input(&mut self, text: &str) -> Option { + let keyword = text.trim().to_ascii_uppercase(); + match &mut self.step { + Step::PickDimension if matches!(keyword.as_str(), "M" | "MULTIPLE") => { + self.step = Step::PickDimensions(Vec::new()); + Some(CmdResult::NeedPoint) + } + Step::PickCrossing(handles) if matches!(keyword.as_str(), "A" | "AUTO") => { + Some(Self::automatic(handles)) + } + Step::PickCrossing(handles) if matches!(keyword.as_str(), "M" | "MANUAL") => { + self.step = Step::ManualFirst(handles.clone()); + Some(CmdResult::NeedPoint) + } + Step::PickCrossing(handles) if matches!(keyword.as_str(), "R" | "REMOVE") => { + Some(Self::remove(handles)) + } + _ => None, + } + } + + fn on_point(&mut self, point: DVec3) -> CmdResult { + match &self.step { + Step::ManualFirst(handles) => { + self.step = Step::ManualSecond(handles.clone(), point); + CmdResult::NeedPoint + } + Step::ManualSecond(handles, first) => Self::marker( + format!( + "__DIMBREAK_MANUAL__{}|{:.15},{:.15},{:.15}|{:.15},{:.15},{:.15}", + Self::handles(handles), + first.x, + first.y, + first.z, + point.x, + point.y, + point.z + ), + handles[0], + ), + _ => CmdResult::NeedPoint, + } } fn on_enter(&mut self) -> CmdResult { - // Auto mode: apply to all crossings - if let Step::PickCrossing { dim_handle } = &self.step { - let dim_h = *dim_handle; - use acadrust::entities::XLine; - let mut xl = XLine::default(); - xl.common.layer = format!("__DIMBREAK_AUTO__{}", dim_h.value()); - return CmdResult::ReplaceEntity(dim_h, vec![acadrust::EntityType::XLine(xl)]); + match &self.step { + Step::PickDimensions(handles) if !handles.is_empty() => { + self.step = Step::PickCrossing(handles.clone()); + CmdResult::NeedPoint + } + Step::PickCrossing(handles) => Self::automatic(handles), + _ => CmdResult::Cancel, } - CmdResult::Cancel } } - -// ── Autocomplete registry ───────────────────────────────── -inventory::submit!(crate::command::CommandRegistration { names: &["DIMBREAK"] }); // DimBreakCommand +inventory::submit!(crate::command::CommandRegistration { names: &["DIMBREAK"] }); diff --git a/src/modules/annotate/dimedit.rs b/src/modules/annotate/dimedit.rs index 036200505..948ca53c9 100644 --- a/src/modules/annotate/dimedit.rs +++ b/src/modules/annotate/dimedit.rs @@ -1,13 +1,11 @@ -// DIMEDIT command — edit dimension text or reset it to the measured value. -// -// Workflow: -// 1. Pick a dimension entity -// 2. Enter new text (blank = reset to auto-measured value, "<>" = measured value placeholder) +// DIMEDIT — edit dimension text, rotation, extension-line obliquing or home position. use acadrust::Handle; use glam::DVec3; -use crate::command::{CadCommand, CmdResult}; +use crate::command::{ + CadCommand, CmdOption, CmdResult, DimensionEditOperation, InputKind, +}; use crate::modules::{IconKind, ModuleEvent, ToolDef}; use crate::t; @@ -23,8 +21,11 @@ pub fn tool() -> ToolDef { } enum Step { - PickDim, - EnterText { handle: Handle }, + Choose, + NewText, + Rotate, + Oblique, + Select(DimensionEditOperation), } pub struct DimEditCommand { @@ -33,9 +34,12 @@ pub struct DimEditCommand { impl DimEditCommand { pub fn new() -> Self { - Self { - step: Step::PickDim, - } + Self { step: Step::Choose } + } + + fn select(&mut self, operation: DimensionEditOperation) -> CmdResult { + self.step = Step::Select(operation); + CmdResult::NeedPoint } } @@ -45,48 +49,106 @@ impl CadCommand for DimEditCommand { } fn prompt(&self) -> String { - match &self.step { - Step::PickDim => t!("DIMEDIT Select dimension:").into_owned(), - Step::EnterText { .. } => { - t!("DIMEDIT Enter text override (blank = reset to measured):").into_owned() + match self.step { + Step::Choose => { + t!("DIMEDIT Enter type of dimension editing [Home/New/Rotate/Oblique] :") + .into_owned() + } + Step::NewText => t!("DIMEDIT Enter new dimension text :").into_owned(), + Step::Rotate => t!("DIMEDIT Specify angle for dimension text:").into_owned(), + Step::Oblique => { + t!("DIMEDIT Enter obliquing angle (press Enter for none):").into_owned() + } + Step::Select(_) => t!("DIMEDIT Select objects:").into_owned(), + } + } + + fn options(&self) -> Vec { + if !matches!(self.step, Step::Choose) { + return Vec::new(); + } + vec![ + CmdOption::new("Home", "HOME"), + CmdOption::new("New", "NEW"), + CmdOption::new("Rotate", "ROTATE"), + CmdOption::new("Oblique", "OBLIQUE"), + ] + } + + fn input_kind(&self) -> InputKind { + match self.step { + Step::NewText => InputKind::FreeText, + Step::Select(_) => InputKind::Point, + Step::Choose | Step::Rotate | Step::Oblique => InputKind::SingleToken, + } + } + + fn is_selection_gathering(&self) -> bool { + matches!(self.step, Step::Select(_)) + } + + fn on_selection_complete(&mut self, handles: Vec) -> CmdResult { + let Step::Select(operation) = &self.step else { + return CmdResult::Cancel; + }; + if handles.is_empty() { + CmdResult::Cancel + } else { + CmdResult::EditDimensions { + handles, + operation: operation.clone(), } } } - fn needs_entity_pick(&self) -> bool { - matches!(self.step, Step::PickDim) - } - - fn on_entity_pick(&mut self, handle: Handle, _pt: DVec3) -> CmdResult { - if handle.is_null() { - return CmdResult::NeedPoint; - } - self.step = Step::EnterText { handle }; - CmdResult::NeedPoint - } - - fn wants_text_input(&self) -> bool { - matches!(self.step, Step::EnterText { .. }) - } - fn on_text_input(&mut self, text: &str) -> Option { - let handle = match &self.step { - Step::EnterText { handle } => *handle, - _ => return None, - }; - // Empty = reset to auto-measured, "<>" = keep measured, else override - let new_text = text.trim().to_string(); - Some(CmdResult::DdeditEntity { handle, new_text }) + let value = text.trim(); + let keyword = value.to_ascii_uppercase(); + match self.step { + Step::Choose => match keyword.as_str() { + "H" | "HOME" => Some(self.select(DimensionEditOperation::Home)), + "N" | "NEW" => { + self.step = Step::NewText; + Some(CmdResult::NeedPoint) + } + "R" | "ROTATE" => { + self.step = Step::Rotate; + Some(CmdResult::NeedPoint) + } + "O" | "OBLIQUE" => { + self.step = Step::Oblique; + Some(CmdResult::NeedPoint) + } + _ => None, + }, + Step::NewText => Some(self.select(DimensionEditOperation::NewText( + if value == "<>" { String::new() } else { text.to_string() }, + ))), + Step::Rotate => value + .parse::() + .ok() + .map(|degrees| self.select(DimensionEditOperation::Rotate(degrees))), + Step::Oblique => value + .parse::() + .ok() + .filter(|degrees| (-85.0..=85.0).contains(degrees)) + .map(|degrees| self.select(DimensionEditOperation::Oblique(degrees))), + Step::Select(_) => None, + } } - fn on_point(&mut self, _pt: DVec3) -> CmdResult { + fn on_point(&mut self, _point: DVec3) -> CmdResult { CmdResult::NeedPoint } + fn on_enter(&mut self) -> CmdResult { - CmdResult::Cancel + match self.step { + Step::Choose => self.select(DimensionEditOperation::Home), + Step::NewText => self.select(DimensionEditOperation::NewText(String::new())), + Step::Oblique => self.select(DimensionEditOperation::Oblique(0.0)), + Step::Rotate | Step::Select(_) => CmdResult::Cancel, + } } } - -// ── Autocomplete registry ───────────────────────────────── -inventory::submit!(crate::command::CommandRegistration { names: &["DIMEDIT"] }); // DimEditCommand +inventory::submit!(crate::command::CommandRegistration { names: &["DIMEDIT"] }); diff --git a/src/modules/annotate/dimjogline.rs b/src/modules/annotate/dimjogline.rs index 02fbd90b3..43e166965 100644 --- a/src/modules/annotate/dimjogline.rs +++ b/src/modules/annotate/dimjogline.rs @@ -1,13 +1,10 @@ -// DIMJOGLINE command — add a jog (zigzag) symbol to a linear or aligned dimension. -// -// Workflow: -// 1. Pick the dimension -// 2. Click the position on the dimension line where the jog should appear +// DIMJOGLINE — add or remove a jog on a linear/aligned dimension. -use acadrust::Handle; -use glam::DVec3; +use acadrust::entities::Dimension; +use acadrust::{EntityType, Handle}; +use glam::{DVec3, Vec3}; -use crate::command::{CadCommand, CmdResult}; +use crate::command::{CadCommand, CmdOption, CmdResult, InputKind}; use crate::modules::{IconKind, ModuleEvent, ToolDef}; use crate::scene::model::wire_model::WireModel; use crate::t; @@ -30,12 +27,76 @@ enum Step { pub struct DimJogLineCommand { step: Step, + remove: bool, + picked_entity: Option, + dimension: Option, } impl DimJogLineCommand { pub fn new() -> Self { Self { step: Step::PickDim, + remove: false, + picked_entity: None, + dimension: None, + } + } + + fn result(handle: Handle, point: Option) -> CmdResult { + use acadrust::entities::XLine; + let mut marker = XLine::default(); + marker.common.layer = match point { + Some(point) => format!( + "__DIMJOG__{}|{:.15},{:.15},{:.15}", + handle.value(), point.x, point.y, point.z + ), + None => format!("__DIMJOG_REMOVE__{}", handle.value()), + }; + CmdResult::ReplaceEntity(handle, vec![EntityType::XLine(marker)]) + } + + fn default_position(dimension: &Dimension) -> Option { + let (first, second, definition, axis) = match dimension { + Dimension::Linear(value) => ( + value.first_point, + value.second_point, + value.definition_point, + DVec3::new(value.rotation.cos(), value.rotation.sin(), 0.0), + ), + Dimension::Aligned(value) => { + let first = DVec3::new(value.first_point.x, value.first_point.y, value.first_point.z); + let second = DVec3::new(value.second_point.x, value.second_point.y, value.second_point.z); + ( + value.first_point, + value.second_point, + value.definition_point, + (second - first).try_normalize().unwrap_or(DVec3::X), + ) + } + _ => return None, + }; + let first = DVec3::new(first.x, first.y, first.z); + let second = DVec3::new(second.x, second.y, second.z); + let definition = DVec3::new(definition.x, definition.y, definition.z); + let axis = axis.try_normalize().unwrap_or(DVec3::X); + let perpendicular = DVec3::new(-axis.y, axis.x, 0.0); + let offset = definition.dot(perpendicular); + let first_on_line = first + perpendicular * (offset - first.dot(perpendicular)); + let second_on_line = second + perpendicular * (offset - second.dot(perpendicular)); + let midpoint = (first_on_line + second_on_line) * 0.5; + + let text = dimension.base().text_middle_point; + let text = DVec3::new(text.x, text.y, text.z); + let line = second_on_line - first_on_line; + let length_squared = line.length_squared(); + if length_squared <= 1.0e-18 { + return Some(midpoint); + } + let parameter = (text - first_on_line).dot(line) / length_squared; + if text.is_finite() && (0.0..=1.0).contains(¶meter) { + Some((first_on_line + text) * 0.5) + } else { + Some(midpoint) } } } @@ -46,90 +107,129 @@ impl CadCommand for DimJogLineCommand { } fn prompt(&self) -> String { - match &self.step { - Step::PickDim => t!("DIMJOGLINE Select linear or aligned dimension:").into_owned(), - Step::PickJogPos { .. } => t!("DIMJOGLINE Specify jog location:").into_owned(), + match self.step { + Step::PickDim if self.remove => { + t!("DIMJOGLINE Select dimension to remove jog:").into_owned() + } + Step::PickDim => { + t!("DIMJOGLINE Select dimension to add jog or [Remove]:").into_owned() + } + Step::PickJogPos { .. } => { + t!("DIMJOGLINE Specify jog location (or press Enter):").into_owned() + } } } + fn options(&self) -> Vec { + if matches!(self.step, Step::PickDim) && !self.remove { + vec![CmdOption::new("Remove", "REMOVE")] + } else { + Vec::new() + } + } + + fn input_kind(&self) -> InputKind { + InputKind::Point + } + + fn point_step_accepts_keywords(&self) -> bool { + matches!(self.step, Step::PickDim) && !self.remove + } + fn needs_entity_pick(&self) -> bool { matches!(self.step, Step::PickDim) } - fn on_entity_pick(&mut self, handle: Handle, _pt: DVec3) -> CmdResult { + fn inject_before_entity_pick(&self) -> bool { + matches!(self.step, Step::PickDim) + } + + fn inject_picked_entity(&mut self, entity: EntityType) { + self.picked_entity = Some(entity); + } + + fn on_entity_pick(&mut self, handle: Handle, _point: DVec3) -> CmdResult { + let Some(EntityType::Dimension(dimension @ (Dimension::Linear(_) | Dimension::Aligned(_)))) = + self.picked_entity.take() + else { + return CmdResult::ReportError( + t!("DIMJOGLINE: select a linear or aligned dimension.").into_owned(), + ); + }; if handle.is_null() { return CmdResult::NeedPoint; } + if self.remove { + return Self::result(handle, None); + } + self.dimension = Some(dimension); self.step = Step::PickJogPos { handle }; CmdResult::NeedPoint } - fn on_point(&mut self, pt: DVec3) -> CmdResult { - if let Step::PickJogPos { handle } = &self.step { - let h = *handle; - // Emit sentinel for commands.rs to store the jog position - use acadrust::entities::XLine; - let mut xl = XLine::default(); - xl.common.layer = format!("__DIMJOG__{},{:.6},{:.6}", h.value(), pt.x, pt.z); - return CmdResult::ReplaceEntity(h, vec![acadrust::EntityType::XLine(xl)]); + fn on_text_input(&mut self, text: &str) -> Option { + if matches!(self.step, Step::PickDim) + && matches!(text.trim().to_ascii_uppercase().as_str(), "R" | "REMOVE") + { + self.remove = true; + Some(CmdResult::NeedPoint) + } else { + None + } + } + + fn on_point(&mut self, point: DVec3) -> CmdResult { + match self.step { + Step::PickJogPos { handle } => Self::result(handle, Some(point)), + Step::PickDim => CmdResult::NeedPoint, } - CmdResult::NeedPoint } fn on_enter(&mut self) -> CmdResult { - CmdResult::Cancel + match (&self.step, &self.dimension) { + (Step::PickJogPos { handle }, Some(dimension)) => Self::default_position(dimension) + .map(|point| Self::result(*handle, Some(point))) + .unwrap_or(CmdResult::Cancel), + _ => CmdResult::Cancel, + } } - fn on_mouse_move(&mut self, pt: DVec3) -> Option { let pt = pt.as_vec3(); + fn on_mouse_move(&mut self, point: DVec3) -> Option { if !matches!(self.step, Step::PickJogPos { .. }) { return None; } - let d = 0.3_f32; - Some(WireModel { - bg_adapt: None, - point_marker: None, - taper_widths: Vec::new(), - pattern_stations: Vec::new(), - world_width: 0.0, - depth_override: None, - display_visible: true, - plot_visible: true, - fill_is_3d: false, - fill_is_2d_solid: false, - render_instance: None, - pick_tris: Vec::new(), - pick_tris_low: Vec::new(), - dash_from_start: false, - dash_align_end: None, - text_verts: Vec::new(), - name: "dimjog_preview".into(), - // Jog zigzag in the XY drawing plane (Z is elevation, ~0). The old - // marker varied Z, so in the top-down view it collapsed to a flat - // line instead of a zigzag. (#150) - points: vec![ - [pt.x - d, pt.y, pt.z], - [pt.x - d * 0.3, pt.y + d, pt.z], - [pt.x + d * 0.3, pt.y - d, pt.z], - [pt.x + d, pt.y, pt.z], - ], - points_low: Vec::new(), - color: WireModel::CYAN, - selected: false, - pattern_length: 0.0, - pattern: [0.0; 8], - line_weight_px: 1.2, - snap_pts: vec![], - tangent_geoms: vec![], - aci: 0, - key_vertices: vec![], - aabb: WireModel::UNBOUNDED_AABB, - plinegen: true, - fill_tris: vec![], - fill_tris_low: Vec::new(), - }) + let axis = self + .dimension + .as_ref() + .and_then(|dimension| match dimension { + Dimension::Linear(value) => { + Some(Vec3::new(value.rotation.cos() as f32, value.rotation.sin() as f32, 0.0)) + } + Dimension::Aligned(value) => Some(Vec3::new( + (value.second_point.x - value.first_point.x) as f32, + (value.second_point.y - value.first_point.y) as f32, + 0.0, + )), + _ => None, + }) + .and_then(Vec3::try_normalize) + .unwrap_or(Vec3::X); + let perpendicular = Vec3::new(-axis.y, axis.x, 0.0); + let center = point.as_vec3(); + let size = 0.3; + let points = vec![ + center - axis * size, + center - axis * size * 0.25 + perpendicular * size, + center + axis * size * 0.25 - perpendicular * size, + center + axis * size, + ]; + let mut preview = WireModel::default(); + preview.name = "dimjog_preview".into(); + preview.points = points.into_iter().map(|point| point.to_array()).collect(); + preview.color = WireModel::CYAN; + preview.line_weight_px = 1.2; + Some(preview) } } - -// ── Autocomplete registry ───────────────────────────────── -inventory::submit!(crate::command::CommandRegistration { names: &["DIMJOGLINE"] }); // DimJogLineCommand +inventory::submit!(crate::command::CommandRegistration { names: &["DIMJOGLINE"] }); diff --git a/src/modules/annotate/dimspace.rs b/src/modules/annotate/dimspace.rs index de6c19bf5..f52a748d9 100644 --- a/src/modules/annotate/dimspace.rs +++ b/src/modules/annotate/dimspace.rs @@ -3,12 +3,12 @@ // Workflow: // 1. Select the base dimension // 2. Select the other dimensions to space (click each, Enter to finish) -// 3. Enter spacing value (or 0 for automatic equal spacing) +// 3. Enter a non-negative spacing value, or choose Auto -use acadrust::Handle; +use acadrust::{EntityType, Handle}; use glam::DVec3; -use crate::command::{CadCommand, CmdResult}; +use crate::command::{CadCommand, CmdOption, CmdResult, InputKind, SelectionEntity}; use crate::modules::{IconKind, ModuleEvent, ToolDef}; use crate::t; @@ -31,12 +31,14 @@ enum Step { pub struct DimSpaceCommand { step: Step, + picked_entity: Option, } impl DimSpaceCommand { pub fn new() -> Self { Self { step: Step::PickBase, + picked_entity: None, } } } @@ -54,12 +56,66 @@ impl CadCommand for DimSpaceCommand { count = others.len() ) .into_owned(), - Step::EnterSpacing { .. } => t!("DIMSPACE Enter value (0 = auto):").into_owned(), + Step::EnterSpacing { .. } => { + t!("DIMSPACE Specify distance between dimensions or [Auto] :") + .into_owned() + } + } + } + + fn options(&self) -> Vec { + matches!(self.step, Step::EnterSpacing { .. }) + .then(|| vec![CmdOption::new("Auto", "AUTO")]) + .unwrap_or_default() + } + + fn input_kind(&self) -> InputKind { + if matches!(self.step, Step::EnterSpacing { .. }) { + InputKind::SingleToken + } else { + InputKind::Point } } fn needs_entity_pick(&self) -> bool { - matches!(self.step, Step::PickBase | Step::PickOthers { .. }) + matches!(self.step, Step::PickBase) + } + + fn inject_before_entity_pick(&self) -> bool { + matches!(self.step, Step::PickBase) + } + + fn inject_picked_entity(&mut self, entity: EntityType) { + self.picked_entity = Some(entity); + } + + fn is_selection_gathering(&self) -> bool { + matches!(self.step, Step::PickOthers { .. }) + } + + fn selection_entities_exclude_locked(&self) -> bool { + true + } + + fn inject_selection_entities(&mut self, entities: Vec) { + let Step::PickOthers { base, others } = &mut self.step else { + return; + }; + others.clear(); + for selected in entities { + if selected.handle != *base + && matches!( + selected.entity, + EntityType::Dimension( + acadrust::entities::Dimension::Linear(_) + | acadrust::entities::Dimension::Aligned(_) + ) + ) + && !others.contains(&selected.handle) + { + others.push(selected.handle); + } + } } fn on_entity_pick(&mut self, handle: Handle, _pt: DVec3) -> CmdResult { @@ -68,29 +124,60 @@ impl CadCommand for DimSpaceCommand { } match &mut self.step { Step::PickBase => { + if !matches!( + self.picked_entity.take(), + Some(EntityType::Dimension( + acadrust::entities::Dimension::Linear(_) + | acadrust::entities::Dimension::Aligned(_) + )) + ) { + return CmdResult::ReportError( + t!("DIMSPACE: select a linear or aligned dimension.").into_owned(), + ); + } self.step = Step::PickOthers { base: handle, others: vec![], }; CmdResult::NeedPoint } - Step::PickOthers { others, .. } => { - if !others.contains(&handle) { - others.push(handle); - } - CmdResult::NeedPoint - } _ => CmdResult::NeedPoint, } } - fn wants_text_input(&self) -> bool { - matches!(self.step, Step::EnterSpacing { .. }) + fn on_selection_complete(&mut self, _handles: Vec) -> CmdResult { + let Step::PickOthers { base, others } = &self.step else { + return CmdResult::Cancel; + }; + if others.is_empty() { + return CmdResult::ReportError( + t!("DIMSPACE: select one or more linear or aligned dimensions.").into_owned(), + ); + } + let base = *base; + let others = others.clone(); + self.step = Step::EnterSpacing { base, others }; + CmdResult::NeedPoint } fn on_text_input(&mut self, text: &str) -> Option { if let Step::EnterSpacing { base, others } = &self.step { - let spacing: f64 = text.trim().parse().unwrap_or(0.0); + let token = text.trim(); + let spacing = if matches!(token.to_ascii_uppercase().as_str(), "A" | "AUTO") { + "AUTO".to_string() + } else { + let Ok(value) = token.parse::() else { + return Some(CmdResult::ReportError( + t!("DIMSPACE: enter a non-negative spacing value or Auto.").into_owned(), + )); + }; + if value < 0.0 { + return Some(CmdResult::ReportError( + t!("DIMSPACE: spacing value cannot be negative.").into_owned(), + )); + } + value.to_string() + }; let b = *base; let o = others.clone(); // Emit sentinel for commands.rs to handle @@ -116,15 +203,12 @@ impl CadCommand for DimSpaceCommand { } fn on_enter(&mut self) -> CmdResult { - match &self.step { - Step::PickOthers { base, others } if !others.is_empty() => { - let b = *base; - let o = others.clone(); - self.step = Step::EnterSpacing { base: b, others: o }; - CmdResult::NeedPoint - } - _ => CmdResult::Cancel, + if matches!(self.step, Step::EnterSpacing { .. }) { + return self + .on_text_input("AUTO") + .unwrap_or(CmdResult::Cancel); } + CmdResult::Cancel } } diff --git a/src/modules/annotate/dimtedit.rs b/src/modules/annotate/dimtedit.rs index 97c28168e..cb6119e5d 100644 --- a/src/modules/annotate/dimtedit.rs +++ b/src/modules/annotate/dimtedit.rs @@ -1,13 +1,10 @@ -// DIMTEDIT command — reposition the text of an existing dimension. -// -// Workflow: -// 1. Pick a dimension entity -// 2. Click the new text position (entity data is injected by update.rs after pick) +// DIMTEDIT — reposition, justify, home or rotate existing dimension text. +use acadrust::entities::{AttachmentPointType, Dimension}; use acadrust::{EntityType, Handle}; use glam::DVec3; -use crate::command::{CadCommand, CmdResult}; +use crate::command::{CadCommand, CmdOption, CmdResult, InputKind}; use crate::modules::{IconKind, ModuleEvent, ToolDef}; use crate::scene::model::wire_model::WireModel; use crate::t; @@ -29,18 +26,47 @@ enum Step { handle: Handle, entity: Option, }, + EnterAngle { + handle: Handle, + entity: Option, + }, } pub struct DimTeditCommand { step: Step, + picked_entity: Option, +} + +#[derive(Clone, Copy)] +enum Placement { + Left, + Right, + Center, + Home, } impl DimTeditCommand { pub fn new() -> Self { Self { step: Step::PickDim, + picked_entity: None, } } + + fn finish_placement( + handle: Handle, + entity: &mut Option, + placement: Placement, + ) -> CmdResult { + let Some(mut entity) = entity.take() else { + return CmdResult::NeedPoint; + }; + let EntityType::Dimension(dimension) = &mut entity else { + return CmdResult::Cancel; + }; + apply_placement(dimension, placement); + CmdResult::UpdateEntityAndFinish { handle, entity } + } } impl CadCommand for DimTeditCommand { @@ -49,47 +75,123 @@ impl CadCommand for DimTeditCommand { } fn prompt(&self) -> String { - match &self.step { + match self.step { Step::PickDim => t!("DIMTEDIT Select dimension:").into_owned(), - Step::PickTextPos { .. } => { - t!("DIMTEDIT Specify new location for dimension text:").into_owned() + Step::PickTextPos { .. } => t!( + "DIMTEDIT Specify new location for dimension text or [Left/Right/Center/Home/Angle]:" + ) + .into_owned(), + Step::EnterAngle { .. } => { + t!("DIMTEDIT Specify angle for dimension text:").into_owned() } } } + fn options(&self) -> Vec { + if !matches!(self.step, Step::PickTextPos { .. }) { + return Vec::new(); + } + vec![ + CmdOption::new("Left", "LEFT"), + CmdOption::new("Right", "RIGHT"), + CmdOption::new("Center", "CENTER"), + CmdOption::new("Home", "HOME"), + CmdOption::new("Angle", "ANGLE"), + ] + } + + fn input_kind(&self) -> InputKind { + match self.step { + Step::EnterAngle { .. } => InputKind::SingleToken, + Step::PickDim | Step::PickTextPos { .. } => InputKind::Point, + } + } + + fn point_step_accepts_keywords(&self) -> bool { + matches!(self.step, Step::PickTextPos { .. }) + } + fn needs_entity_pick(&self) -> bool { matches!(self.step, Step::PickDim) } - fn on_entity_pick(&mut self, handle: Handle, _pt: DVec3) -> CmdResult { + fn inject_before_entity_pick(&self) -> bool { + matches!(self.step, Step::PickDim) + } + + fn on_entity_pick(&mut self, handle: Handle, _point: DVec3) -> CmdResult { if handle.is_null() { return CmdResult::NeedPoint; } + if !matches!(self.picked_entity.as_ref(), Some(EntityType::Dimension(_))) { + self.picked_entity = None; + return CmdResult::ReportError( + t!("DIMTEDIT: select a dimension.").into_owned(), + ); + } self.step = Step::PickTextPos { handle, - entity: None, + entity: self.picked_entity.take(), }; CmdResult::NeedPoint } - fn on_point(&mut self, pt: DVec3) -> CmdResult { - if let Step::PickTextPos { handle, entity } = &mut self.step { - let h = *handle; - if let Some(mut ent) = entity.take() { - if let EntityType::Dimension(ref mut d) = ent { - let new_pt = acadrust::types::Vector3::new(pt.x, pt.y, pt.z); - d.base_mut().text_middle_point = new_pt; - d.base_mut().insertion_point = new_pt; - // Pin the text to this location, else the renderer recomputes - // the style-default placement and the move is discarded. - d.base_mut().text_user_positioned = true; + fn on_text_input(&mut self, text: &str) -> Option { + let keyword = text.trim().to_ascii_uppercase(); + match &mut self.step { + Step::PickTextPos { handle, entity } => match keyword.as_str() { + "L" | "LEFT" => Some(Self::finish_placement(*handle, entity, Placement::Left)), + "R" | "RIGHT" => { + Some(Self::finish_placement(*handle, entity, Placement::Right)) } - return CmdResult::ReplaceEntity(h, vec![ent]); + "C" | "CENTER" => { + Some(Self::finish_placement(*handle, entity, Placement::Center)) + } + "H" | "HOME" => Some(Self::finish_placement(*handle, entity, Placement::Home)), + "A" | "ANGLE" => { + let handle = *handle; + let entity = entity.take(); + self.step = Step::EnterAngle { handle, entity }; + Some(CmdResult::NeedPoint) + } + _ => None, + }, + Step::EnterAngle { handle, entity } => { + let degrees = text.trim().parse::().ok()?; + let Some(mut entity) = entity.take() else { + return Some(CmdResult::NeedPoint); + }; + let EntityType::Dimension(dimension) = &mut entity else { + return Some(CmdResult::Cancel); + }; + dimension.base_mut().text_rotation = degrees.to_radians(); + Some(CmdResult::UpdateEntityAndFinish { + handle: *handle, + entity, + }) } - // No entity yet — wait for inject - CmdResult::NeedPoint - } else { - CmdResult::NeedPoint + Step::PickDim => None, + } + } + + fn on_point(&mut self, point: DVec3) -> CmdResult { + let Step::PickTextPos { handle, entity } = &mut self.step else { + return CmdResult::NeedPoint; + }; + let Some(mut entity) = entity.take() else { + return CmdResult::NeedPoint; + }; + let EntityType::Dimension(dimension) = &mut entity else { + return CmdResult::Cancel; + }; + let point = acadrust::types::Vector3::new(point.x, point.y, point.z); + let base = dimension.base_mut(); + base.text_middle_point = point; + base.insertion_point = point; + base.text_user_positioned = true; + CmdResult::UpdateEntityAndFinish { + handle: *handle, + entity, } } @@ -97,63 +199,102 @@ impl CadCommand for DimTeditCommand { CmdResult::Cancel } - fn on_mouse_move(&mut self, pt: DVec3) -> Option { let pt = pt.as_vec3(); + fn on_mouse_move(&mut self, point: DVec3) -> Option { if !matches!(self.step, Step::PickTextPos { .. }) { return None; } + let point = point.as_vec3(); let d = 0.2_f32; Some(WireModel { - bg_adapt: None, - point_marker: None, - taper_widths: Vec::new(), - pattern_stations: Vec::new(), - world_width: 0.0, - depth_override: None, - display_visible: true, - plot_visible: true, - fill_is_3d: false, - fill_is_2d_solid: false, - render_instance: None, - pick_tris: Vec::new(), - pick_tris_low: Vec::new(), - dash_from_start: false, - dash_align_end: None, - text_verts: Vec::new(), name: "dimtedit_preview".into(), - // Marker box in the XY drawing plane (Z is elevation, ~0). The old - // box varied Z, so in the top-down view it collapsed to a flat line - // instead of a square. (#150) points: vec![ - [pt.x - d, pt.y - d, pt.z], - [pt.x + d, pt.y - d, pt.z], - [pt.x + d, pt.y + d, pt.z], - [pt.x - d, pt.y + d, pt.z], - [pt.x - d, pt.y - d, pt.z], + [point.x - d, point.y - d, point.z], + [point.x + d, point.y - d, point.z], + [point.x + d, point.y + d, point.z], + [point.x - d, point.y + d, point.z], + [point.x - d, point.y - d, point.z], ], - points_low: Vec::new(), color: WireModel::CYAN, - selected: false, - pattern_length: 0.0, - pattern: [0.0; 8], - line_weight_px: 1.0, - snap_pts: vec![], - tangent_geoms: vec![], - aci: 0, - key_vertices: vec![], - aabb: WireModel::UNBOUNDED_AABB, - plinegen: true, - fill_tris: vec![], - fill_tris_low: Vec::new(), + ..WireModel::default() }) } fn inject_picked_entity(&mut self, entity: EntityType) { - if let Step::PickTextPos { entity: slot, .. } = &mut self.step { - *slot = Some(entity); + match &mut self.step { + Step::PickTextPos { entity: slot, .. } | Step::EnterAngle { entity: slot, .. } => { + *slot = Some(entity); + } + Step::PickDim => self.picked_entity = Some(entity), } } } +fn dimension_line_endpoints(dimension: &Dimension) -> Option<(DVec3, DVec3)> { + let (first, second, definition, axis) = match dimension { + Dimension::Linear(value) => ( + value.first_point, + value.second_point, + value.definition_point, + DVec3::new(value.rotation.cos(), value.rotation.sin(), 0.0), + ), + Dimension::Aligned(value) => { + let delta = DVec3::new( + value.second_point.x - value.first_point.x, + value.second_point.y - value.first_point.y, + 0.0, + ); + if delta.length_squared() <= 1.0e-18 { + return None; + } + ( + value.first_point, + value.second_point, + value.definition_point, + delta.normalize(), + ) + } + _ => return None, + }; + let first = DVec3::new(first.x, first.y, first.z); + let second = DVec3::new(second.x, second.y, second.z); + let definition = DVec3::new(definition.x, definition.y, definition.z); + let perpendicular = DVec3::new(-axis.y, axis.x, 0.0); + let project = |point: DVec3| { + point + perpendicular * (definition - point).dot(perpendicular) + }; + let first = project(first); + let second = project(second); + if first.dot(axis) <= second.dot(axis) { + Some((first, second)) + } else { + Some((second, first)) + } +} -// ── Autocomplete registry ───────────────────────────────── -inventory::submit!(crate::command::CommandRegistration { names: &["DIMTED", "DIMTEDIT"] }); // DimTeditCommand +fn apply_placement(dimension: &mut Dimension, placement: Placement) { + if matches!(placement, Placement::Home) { + let base = dimension.base_mut(); + base.text_middle_point = acadrust::types::Vector3::ZERO; + base.insertion_point = acadrust::types::Vector3::ZERO; + base.text_user_positioned = false; + base.attachment_point = AttachmentPointType::MiddleCenter; + return; + } + let Some((left, right)) = dimension_line_endpoints(dimension) else { + return; + }; + let (point, attachment) = match placement { + Placement::Left => (left, AttachmentPointType::MiddleLeft), + Placement::Right => (right, AttachmentPointType::MiddleRight), + Placement::Center => ((left + right) * 0.5, AttachmentPointType::MiddleCenter), + Placement::Home => unreachable!(), + }; + let point = acadrust::types::Vector3::new(point.x, point.y, point.z); + let base = dimension.base_mut(); + base.text_middle_point = point; + base.insertion_point = point; + base.text_user_positioned = true; + base.attachment_point = attachment; +} + +inventory::submit!(crate::command::CommandRegistration { names: &["DIMTED", "DIMTEDIT"] }); diff --git a/src/modules/annotate/jogged_radius_dim.rs b/src/modules/annotate/jogged_radius_dim.rs index 711935b49..b88766a2a 100644 --- a/src/modules/annotate/jogged_radius_dim.rs +++ b/src/modules/annotate/jogged_radius_dim.rs @@ -230,8 +230,10 @@ impl CadCommand for JoggedRadiusDimensionCommand { fn input_kind(&self) -> InputKind { if self.awaiting_text { InputKind::FreeText - } else { + } else if self.awaiting_angle { InputKind::SingleToken + } else { + InputKind::Point } } diff --git a/src/modules/annotate/leader_cmd.rs b/src/modules/annotate/leader_cmd.rs index 0c1552b8f..1456682f8 100644 --- a/src/modules/annotate/leader_cmd.rs +++ b/src/modules/annotate/leader_cmd.rs @@ -10,12 +10,12 @@ // (DXF group 340); editing/erasing them stays in sync via that link. use acadrust::entities::mtext::AttachmentPoint; -use acadrust::entities::{Leader, LeaderCreationType, MText}; +use acadrust::entities::{Leader, LeaderCreationType, LeaderPathType, MText}; use acadrust::types::Vector3; use acadrust::EntityType; use glam::{DVec3, Mat4, Vec3}; -use crate::command::{CadCommand, CmdResult, WorkingPlane}; +use crate::command::{CadCommand, CmdOption, CmdResult, InputKind, WorkingPlane}; use crate::modules::{IconKind, ModuleEvent, ToolDef}; use crate::scene::model::wire_model::WireModel; use crate::t; @@ -31,8 +31,17 @@ pub fn tool() -> ToolDef { } } +#[derive(Clone, Copy, PartialEq, Eq)] +enum Step { + Points, + Format, +} + pub struct LeaderCommand { verts: Vec, + step: Step, + path_type: LeaderPathType, + arrow_enabled: bool, plane: WorkingPlane, dimension_style: String, text_style: String, @@ -56,6 +65,9 @@ impl LeaderCommand { Self { verts: Vec::new(), + step: Step::Points, + path_type: LeaderPathType::StraightLine, + arrow_enabled: true, plane: WorkingPlane::default(), dimension_style: defaults.style_name, text_style: defaults.text_style_name, @@ -91,7 +103,7 @@ impl LeaderCommand { let mut leader_points = local.clone(); let first = local[0]; - let elbow = local[1]; + let elbow = *local.last().unwrap_or(&first); let sign = if elbow.x >= first.x { 1.0 } else { -1.0 }; let landing_end = DVec3::new( @@ -102,7 +114,7 @@ impl LeaderCommand { leader_points.push(landing_end); - let leader = build_leader( + let mut leader = build_leader( &leader_points, Mat4::IDENTITY, &self.dimension_style, @@ -110,6 +122,8 @@ impl LeaderCommand { self.gap, self.arrow_size, ); + leader.path_type = self.path_type; + leader.arrow_enabled = self.arrow_enabled; // The MTEXT starts at the real end of the landing. let (anchor, attach) = @@ -150,25 +164,95 @@ impl CadCommand for LeaderCommand { } fn prompt(&self) -> String { - if self.verts.is_empty() { - t!("LEADER Specify arrowhead point:").into_owned() + if self.step == Step::Format { + return t!("LEADER Enter leader formatting option [Spline/Straight/Arrow/None] :") + .into_owned(); + } + match self.verts.len() { + 0 => t!("LEADER Specify leader start point:").into_owned(), + 1 => t!("LEADER Specify next point:").into_owned(), + _ => t!("LEADER Specify next point or [Annotation/Format/Undo] :") + .into_owned(), + } + } + + fn options(&self) -> Vec { + if self.step == Step::Format { + return vec![ + CmdOption::new("Spline", "SPLINE"), + CmdOption::new("Straight", "STRAIGHT"), + CmdOption::new("Arrow", "ARROW"), + CmdOption::new("None", "NONE"), + ]; + } + if self.verts.len() >= 2 { + vec![ + CmdOption::new("Annotation", "ANNOTATION"), + CmdOption::new("Format", "FORMAT"), + CmdOption::new("Undo", "UNDO"), + ] } else { - t!("LEADER Specify landing point:").into_owned() + Vec::new() + } + } + + fn input_kind(&self) -> InputKind { + if self.step == Step::Format { + InputKind::SingleToken + } else { + InputKind::Point + } + } + + fn point_step_accepts_keywords(&self) -> bool { + self.step == Step::Points && self.verts.len() >= 2 + } + + fn on_text_input(&mut self, text: &str) -> Option { + let keyword = text.trim().to_ascii_uppercase(); + if self.step == Step::Format { + match keyword.as_str() { + "S" | "SPLINE" => self.path_type = LeaderPathType::Spline, + "ST" | "STRAIGHT" => self.path_type = LeaderPathType::StraightLine, + "A" | "ARROW" => self.arrow_enabled = true, + "N" | "NONE" => self.arrow_enabled = false, + _ => return None, + } + self.step = Step::Points; + return Some(CmdResult::NeedPoint); + } + if self.verts.len() < 2 { + return None; + } + match keyword.as_str() { + "A" | "ANNOTATION" => Some(self.finish()), + "F" | "FORMAT" => { + self.step = Step::Format; + Some(CmdResult::NeedPoint) + } + "U" | "UNDO" => { + self.verts.pop(); + Some(CmdResult::NeedPoint) + } + _ => None, } } fn on_point(&mut self, pt: DVec3) -> CmdResult { - self.verts.push(pt); - - if self.verts.len() >= 2 { - self.finish() - } else { - CmdResult::NeedPoint + if self.step != Step::Points { + return CmdResult::NeedPoint; } + self.verts.push(pt); + CmdResult::NeedPoint } fn on_enter(&mut self) -> CmdResult { - self.finish() + if self.step == Step::Format { + self.step = Step::Points; + CmdResult::NeedPoint + } else { + self.finish() + } } fn on_escape(&mut self) -> CmdResult { @@ -176,7 +260,7 @@ impl CadCommand for LeaderCommand { } fn on_mouse_move(&mut self, pt: DVec3) -> Option { - if self.verts.is_empty() { + if self.step != Step::Points || self.verts.is_empty() { return None; } let mut pts: Vec = self diff --git a/src/modules/annotate/linear_dim.rs b/src/modules/annotate/linear_dim.rs index 78a3e6772..263fc8cac 100644 --- a/src/modules/annotate/linear_dim.rs +++ b/src/modules/annotate/linear_dim.rs @@ -6,7 +6,7 @@ use cadkernel::geom2d::{ }; use crate::command::{ - CadCommand, CmdResult, DimensionAssociationInput, InputKind, WorkingPlane, + CadCommand, CmdOption, CmdResult, DimensionAssociationInput, InputKind, WorkingPlane, }; use crate::modules::{IconKind, ModuleEvent, ToolDef}; use crate::scene::model::wire_model::WireModel; @@ -224,11 +224,31 @@ impl CadCommand for LinearDimensionCommand { fn input_kind(&self) -> InputKind { if self.awaiting_text { InputKind::FreeText - } else { + } else if self.awaiting_angle || self.awaiting_rotation { InputKind::SingleToken + } else { + InputKind::Point } } + fn options(&self) -> Vec { + if !matches!(self.step, Step::DimensionLine { .. }) + || self.awaiting_text + || self.awaiting_angle + || self.awaiting_rotation + { + return Vec::new(); + } + vec![ + CmdOption::new("MText", "MTEXT"), + CmdOption::new("Text", "TEXT"), + CmdOption::new("Angle", "ANGLE"), + CmdOption::new("Horizontal", "HORIZONTAL"), + CmdOption::new("Vertical", "VERTICAL"), + CmdOption::new("Rotated", "ROTATED"), + ] + } + fn point_step_accepts_keywords(&self) -> bool { // While typing the override text or angle, route input as a value, not // a point pick / keyword. diff --git a/src/modules/annotate/mleader_cmd.rs b/src/modules/annotate/mleader_cmd.rs index d897d49d4..4ec1e8a4a 100644 --- a/src/modules/annotate/mleader_cmd.rs +++ b/src/modules/annotate/mleader_cmd.rs @@ -472,6 +472,8 @@ impl CadCommand for MLeaderCommand { fn input_kind(&self) -> InputKind { if matches!(self.step, Step::Layer | Step::PreEnterText) { InputKind::FreeText + } else if matches!(self.step, Step::PickPoints | Step::SelectMText) { + InputKind::Point } else { InputKind::SingleToken } diff --git a/src/modules/annotate/mod.rs b/src/modules/annotate/mod.rs index 8c48397fb..6ff2016ae 100644 --- a/src/modules/annotate/mod.rs +++ b/src/modules/annotate/mod.rs @@ -1,6 +1,7 @@ // Annotate module — dimension, text, leader, table, and markup tools. pub mod aligned_dim; +pub mod annotation_scale; pub mod arc_length_dim; pub mod angular_dim; pub mod data_extract; @@ -205,29 +206,33 @@ impl CadModule for AnnotateModule { RibbonGroup { title: "Annotation Scaling", tools: vec![ - RibbonItem::Tool(crate::modules::ToolDef { - id: "ANNOSCALE", - label: "Scale List", - icon: crate::modules::IconKind::Svg(include_bytes!( - "../../../assets/icons/scale_list.svg" - )), - event: crate::modules::ModuleEvent::Command("ANNOSCALE".to_string()), - }), - RibbonItem::Tool(crate::modules::ToolDef { - id: "OBJECTSCALE", - label: "Add Scale", + RibbonItem::LabeledDropdown { + id: "ANNOTATION_CURRENT_SCALE", + label: "Add Current Scale", icon: crate::modules::IconKind::Svg(include_bytes!( "../../../assets/icons/add_scale.svg" )), - // The quick "mark annotative at the current scale" - // action; bare OBJECTSCALE opens the manage dialog. - event: crate::modules::ModuleEvent::Command( - "OBJECTSCALE ADD".to_string(), - ), - }), + items: vec![ + ( + "OBJECTSCALE ADD", + "Add Current Scale", + crate::modules::IconKind::Svg(include_bytes!( + "../../../assets/icons/add_scale.svg" + )), + ), + ( + "OBJECTSCALE DELETE", + "Delete Current Scale", + crate::modules::IconKind::Svg(include_bytes!( + "../../../assets/icons/add_scale.svg" + )), + ), + ], + default: "OBJECTSCALE ADD", + }, RibbonItem::Tool(crate::modules::ToolDef { id: "SCALELISTEDIT", - label: "Scale Edit", + label: "Scale List", icon: crate::modules::IconKind::Svg(include_bytes!( "../../../assets/icons/scale_list.svg" )), @@ -236,13 +241,23 @@ impl CadModule for AnnotateModule { ), }), RibbonItem::Tool(crate::modules::ToolDef { - id: "SYNCPVIEWPORTS", - label: "Sync Scales", + id: "OBJECTSCALE", + label: "Add/Delete Scales", + icon: crate::modules::IconKind::Svg(include_bytes!( + "../../../assets/icons/add_scale.svg" + )), + event: crate::modules::ModuleEvent::Command( + "OBJECTSCALE".to_string(), + ), + }), + RibbonItem::Tool(crate::modules::ToolDef { + id: "ANNORESET", + label: "Sync Scale Positions", icon: crate::modules::IconKind::Svg(include_bytes!( "../../../assets/icons/sync.svg" )), event: crate::modules::ModuleEvent::Command( - "SYNCPVIEWPORTS".to_string(), + "ANNORESET".to_string(), ), }), ], diff --git a/src/modules/annotate/mtext.rs b/src/modules/annotate/mtext.rs index 24aaaf77e..013612d3a 100644 --- a/src/modules/annotate/mtext.rs +++ b/src/modules/annotate/mtext.rs @@ -246,6 +246,8 @@ impl CadCommand for MTextCommand { fn input_kind(&self) -> InputKind { if matches!(self.step, Step::Style) { InputKind::FreeText + } else if matches!(self.step, Step::FirstCorner | Step::OppositeCorner) { + InputKind::Point } else { InputKind::SingleToken } diff --git a/src/modules/annotate/ordinate_dim.rs b/src/modules/annotate/ordinate_dim.rs index 8b917e33f..9611e8aa9 100644 --- a/src/modules/annotate/ordinate_dim.rs +++ b/src/modules/annotate/ordinate_dim.rs @@ -142,8 +142,10 @@ impl CadCommand for OrdinateDimCommand { fn input_kind(&self) -> InputKind { if self.awaiting_text { InputKind::FreeText - } else { + } else if self.awaiting_angle { InputKind::SingleToken + } else { + InputKind::Point } } diff --git a/src/modules/annotate/radius_dim.rs b/src/modules/annotate/radius_dim.rs index b61db83fb..ff69fcdd3 100644 --- a/src/modules/annotate/radius_dim.rs +++ b/src/modules/annotate/radius_dim.rs @@ -137,8 +137,10 @@ impl CadCommand for RadiusDimensionCommand { fn input_kind(&self) -> InputKind { if self.awaiting_text { InputKind::FreeText - } else { + } else if self.awaiting_angle { InputKind::SingleToken + } else { + InputKind::Point } } diff --git a/src/modules/draw/draw/revcloud.rs b/src/modules/draw/draw/revcloud.rs index aa8e12008..9ee23b326 100644 --- a/src/modules/draw/draw/revcloud.rs +++ b/src/modules/draw/draw/revcloud.rs @@ -9,7 +9,7 @@ use cadkernel::space::{PlanarCurve, Plane, Vec3}; use glam::DVec3; use rustc_hash::FxHashMap; -use crate::command::{CadCommand, CmdOption, CmdResult, WorkingPlane}; +use crate::command::{CadCommand, CmdOption, CmdResult, InputKind, WorkingPlane}; use crate::entities::curve::{curve_points, entity_curve, ocs_plane}; use crate::entities::lwpolyline::{is_revision_cloud, revision_cloud_from_curve}; use crate::modules::{IconKind, ModuleEvent, ToolDef}; @@ -666,6 +666,17 @@ impl CadCommand for RevCloudCommand { true } + fn input_kind(&self) -> InputKind { + match self.stage { + Stage::ArcLength | Stage::Style | Stage::Reverse(_) => InputKind::SingleToken, + Stage::Create + | Stage::Object + | Stage::ModifySelect + | Stage::ModifyDraw(_) + | Stage::ModifyErase(_) => InputKind::Point, + } + } + fn point_step_accepts_keywords(&self) -> bool { matches!(self.stage, Stage::Create | Stage::ModifyDraw(_)) } diff --git a/src/modules/draw/draw/wipeout.rs b/src/modules/draw/draw/wipeout.rs index 56f60ca12..32385d301 100644 --- a/src/modules/draw/draw/wipeout.rs +++ b/src/modules/draw/draw/wipeout.rs @@ -8,7 +8,7 @@ use cadkernel::space::Plane; use glam::DVec3; use crate::t; -use crate::command::{CadCommand, CmdOption, CmdResult, WorkingPlane}; +use crate::command::{CadCommand, CmdOption, CmdResult, InputKind, WorkingPlane}; use crate::modules::{IconKind, ModuleEvent, ToolDef}; use crate::scene::model::wire_model::WireModel; @@ -270,6 +270,15 @@ impl CadCommand for WipeoutCommand { ) } + fn input_kind(&self) -> InputKind { + match self.mode { + WipeoutMode::Frames | WipeoutMode::ErasePolyline => InputKind::SingleToken, + WipeoutMode::Draw | WipeoutMode::Polyline | WipeoutMode::Rectangular => { + InputKind::Point + } + } + } + fn point_step_accepts_keywords(&self) -> bool { matches!( self.mode, diff --git a/src/scene/annotative.rs b/src/scene/annotative.rs index 557f178b7..ed5203e26 100644 --- a/src/scene/annotative.rs +++ b/src/scene/annotative.rs @@ -644,6 +644,44 @@ pub fn active_object_context_for_scale( default.or(first) } +/// Reset every alternate annotation-scale representation to the placement of +/// the representation displayed at `scale_handle`. The leaf identity, scale +/// handle and default marker stay intact; only the context payload is copied. +pub fn reset_annotation_context_positions( + doc: &mut CadDocument, + entity: Handle, + scale_handle: Option, +) -> bool { + let Some(source) = active_object_context_for_scale(doc, entity, scale_handle) else { + return false; + }; + let source_handle = source.handle; + let source_kind = source.kind.clone(); + let targets: Vec = annotation_scales_dict(doc, entity) + .and_then(|collection| as_dict(doc, collection)) + .map(|collection| { + collection + .entries + .iter() + .map(|(_, handle)| *handle) + .filter(|handle| *handle != source_handle) + .collect() + }) + .unwrap_or_default(); + + let mut changed = false; + for handle in targets { + let Some(ObjectType::ObjectContextData(context)) = doc.objects.get_mut(&handle) else { + continue; + }; + if context.kind != source_kind { + context.kind = source_kind.clone(); + changed = true; + } + } + changed +} + pub fn effective_annotation_scale_for( doc: &CadDocument, entity: &EntityType,