From 913705106e5daf27fa165c4d0b0ab9d201d19a86 Mon Sep 17 00:00:00 2001 From: Marcel Date: Fri, 11 Sep 2026 20:52:33 +0200 Subject: [PATCH] Support dynamic rectangle resizing via grip editing --- src/app/update/command.rs | 115 ++++++++++++++++++++++++++++++++----- src/app/update/dynamic.rs | 25 ++++++-- src/app/update/viewport.rs | 59 ++++++++++++++++++- src/app/view/mod.rs | 53 +++++++++++++++++ src/entities/lwpolyline.rs | 46 +++++++++------ src/scene/model/object.rs | 1 + src/scene/pick/grip.rs | 18 ++++++ src/ui/overlay.rs | 6 +- 8 files changed, 282 insertions(+), 41 deletions(-) diff --git a/src/app/update/command.rs b/src/app/update/command.rs index e9bb72f3a..2ea8b7504 100644 --- a/src/app/update/command.rs +++ b/src/app/update/command.rs @@ -423,13 +423,37 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task { let i = self.active_tab; if let Some(grip) = self.tabs[i].active_grip.clone() { - if grip.mode == GripEditMode::Stretch { + if matches!(grip.mode, GripEditMode::Stretch | GripEditMode::RectangleResize) { let dyn_locked = self.tabs[i] .dyn_fields .iter() .any(|field| field.buffer.is_some()); - let target = if dyn_locked { + let target = if matches!(grip.mode, GripEditMode::RectangleResize) { + grip.rectangle_frame.map(|(opposite, width_axis, height_axis)| { + let cursor_delta = self.tabs[i].last_cursor_world - opposite; + let mut width = cursor_delta.dot(width_axis); + let mut height = cursor_delta.dot(height_axis); + for field in &self.tabs[i].dyn_fields { + let value = field + .buffer + .as_ref() + .and_then(|buffer| crate::app::expr_eval::eval_number(buffer)); + if let Some(value) = value { + match field.role { + crate::command::DynRole::Width => { + width = value.abs().copysign(width); + } + crate::command::DynRole::Height => { + height = value.abs().copysign(height); + } + _ => {} + } + } + } + opposite + width_axis * width + height_axis * height + }) + } else if dyn_locked { // Distance only: // keep the cursor's current direction. // @@ -506,10 +530,32 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task { } let delta = target - grip.last_world; - let actions: Vec<_> = grip - .targets - .iter() - .map(|target_grip| { + let actions: Vec<_> = if let Some((opposite, width_axis, height_axis)) = grip.rectangle_frame { + let opposite_id = (grip.grip_id + 2) % 4; + let mut edits = Vec::with_capacity(3); + for adjacent_id in [(opposite_id + 1) % 4, (opposite_id + 3) % 4] { + if let Some(original) = self.tabs[i] + .selected_grip_handles + .iter() + .zip(self.tabs[i].selected_grips.iter()) + .find(|(owner, candidate)| **owner == grip.handle && candidate.id == adjacent_id) + .map(|(_, candidate)| candidate.world) + { + let d = original - opposite; + let axis = if d.dot(width_axis).abs() >= d.dot(height_axis).abs() { + width_axis + } else { + height_axis + }; + edits.push((grip.handle, adjacent_id, GripApply::Absolute( + opposite + axis * (target - opposite).dot(axis), + ))); + } + } + edits.push((grip.handle, grip.grip_id, GripApply::Absolute(target))); + edits + } else { + grip.targets.iter().map(|target_grip| { let apply = if target_grip.is_translate { GripApply::Translate(delta) } else { @@ -523,8 +569,8 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task { target_grip.grip_id, apply, ) - }) - .collect(); + }).collect() + }; for (handle, grip_id, apply) in actions { self.tabs[i] @@ -1340,6 +1386,7 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task { if matches!( item.action, GripMenuAction::Stretch + | GripMenuAction::RectangleResize | GripMenuAction::MoveWithText | GripMenuAction::MoveWithDimLine | GripMenuAction::MoveWithLeader @@ -1397,12 +1444,52 @@ pub(super) fn on_tab_close(&mut self, idx: usize) -> Task { || (!is_dimension && g.is_midpoint), ) }; - self.tabs[i].active_grip = Some(GripEdit::single( - popup.handle, - grip_id, - is_translate, - g.world, - )); + if matches!(item.action, GripMenuAction::RectangleResize) { + let corner = |id| { + self.tabs[i] + .selected_grip_handles + .iter() + .zip(self.tabs[i].selected_grips.iter()) + .find(|(owner, grip)| **owner == popup.handle && grip.id == id) + .map(|(_, grip)| grip.world) + }; + if let (Some(p0), Some(p1), Some(p2), Some(opposite)) = ( + corner(0), + corner(1), + corner(2), + corner((popup.grip_id + 2) % 4), + ) { + if let (Some(width_axis), Some(height_axis)) = + ((p1 - p0).try_normalize(), (p2 - p1).try_normalize()) + { + if self.grip_originals.is_empty() { + self.grip_originals = self.tabs[i] + .scene + .document + .get_entity(popup.handle) + .cloned() + .map(|entity| vec![(popup.handle, entity)]) + .unwrap_or_default(); + } + self.tabs[i].active_grip = Some(GripEdit::rectangle_resize( + popup.handle, + popup.grip_id, + g.world, + opposite, + width_axis, + height_axis, + )); + self.sync_dyn_fields(); + } + } + } else { + self.tabs[i].active_grip = Some(GripEdit::single( + popup.handle, + grip_id, + is_translate, + g.world, + )); + } } return Task::none(); } diff --git a/src/app/update/dynamic.rs b/src/app/update/dynamic.rs index 621586f72..89c8c0138 100644 --- a/src/app/update/dynamic.rs +++ b/src/app/update/dynamic.rs @@ -71,6 +71,10 @@ impl OpenCADStudio { // // Grip editing is not an `active_cmd`, so handle it before the normal // command-only path below. + let rectangle_frame = self.tabs[i] + .active_grip + .as_ref() + .and_then(|grip| grip.rectangle_frame); let grip_input = self.tabs[i] .active_grip .as_ref() @@ -93,13 +97,20 @@ impl OpenCADStudio { crate::scene::pick::grip::GripEditMode::RectangleHeight => { (grip.origin_world, Some(crate::command::DynRole::Height)) } + crate::scene::pick::grip::GripEditMode::RectangleResize => { + (grip.origin_world, None) + } }); if let Some((origin, scalar_role)) = grip_input { - let wanted_roles: Vec = scalar_role.map_or_else( - || vec![crate::command::DynRole::Distance, crate::command::DynRole::Angle], - |role| vec![role], - ); + let wanted_roles: Vec = if rectangle_frame.is_some() { + vec![crate::command::DynRole::Width, crate::command::DynRole::Height] + } else { + scalar_role.map_or_else( + || vec![crate::command::DynRole::Distance, crate::command::DynRole::Angle], + |role| vec![role], + ) + }; let current: Vec = self.tabs[i] .dyn_fields .iter() @@ -115,12 +126,14 @@ impl OpenCADStudio { self.tabs[i].dyn_active = 0; } - self.tabs[i].dyn_guide = if scalar_role.is_some() { + self.tabs[i].dyn_guide = if rectangle_frame.is_some() { + crate::command::DynGuide::RectSides + } else if scalar_role.is_some() { crate::command::DynGuide::Radius } else { crate::command::DynGuide::Polar }; - self.tabs[i].dyn_anchor = Some(origin); + self.tabs[i].dyn_anchor = rectangle_frame.map(|frame| frame.0).or(Some(origin)); self.tabs[i].dyn_ref = None; return; } diff --git a/src/app/update/viewport.rs b/src/app/update/viewport.rs index a78e6e370..f9a0ff386 100644 --- a/src/app/update/viewport.rs +++ b/src/app/update/viewport.rs @@ -649,6 +649,7 @@ impl OpenCADStudio { mode: GripEditMode::Stretch, axis, targets, + rectangle_frame: None, } } @@ -1579,6 +1580,30 @@ impl OpenCADStudio { )); let apply_started = Instant::now(); + if let Some((opposite, width_axis, height_axis)) = grip.rectangle_frame { + let delta = snapped - opposite; + let mut width = delta.dot(width_axis); + let mut height = delta.dot(height_axis); + for field in &self.tabs[i].dyn_fields { + let Some(buffer) = field.buffer.as_ref() else { + continue; + }; + let Some(value) = crate::app::expr_eval::eval_number(buffer) else { + continue; + }; + match field.role { + crate::command::DynRole::Width => { + width = value.abs().copysign(width); + } + crate::command::DynRole::Height => { + height = value.abs().copysign(height); + } + _ => {} + } + } + snapped = opposite + width_axis * width + height_axis * height; + self.tabs[i].last_cursor_world = snapped; + } let delta = snapped - grip.last_world; let menu_action = match grip.mode { GripEditMode::Lengthen => { @@ -1596,9 +1621,41 @@ impl OpenCADStudio { GripEditMode::RectangleHeight => { Some(crate::scene::model::object::GripMenuAction::RectangleHeight) } + GripEditMode::RectangleResize => None, GripEditMode::Stretch => None, }; - let actions: Vec<_> = if menu_action.is_some() { + let actions: Vec<_> = if matches!(grip.mode, GripEditMode::RectangleResize) { + let Some((opposite, width_axis, height_axis)) = grip.rectangle_frame else { + return Task::none(); + }; + let opposite_id = (grip.grip_id + 2) % 4; + let adjacent_ids = [(opposite_id + 1) % 4, (opposite_id + 3) % 4]; + let mut edits = Vec::with_capacity(3); + for adjacent_id in adjacent_ids { + let original = self.tabs[i] + .selected_grip_handles + .iter() + .zip(self.tabs[i].selected_grips.iter()) + .find(|(owner, candidate)| { + **owner == grip.handle && candidate.id == adjacent_id + }) + .map(|(_, candidate)| candidate.world); + if let Some(original) = original { + let original_delta = original - opposite; + let axis = if original_delta.dot(width_axis).abs() + >= original_delta.dot(height_axis).abs() + { + width_axis + } else { + height_axis + }; + let point = opposite + axis * (snapped - opposite).dot(axis); + edits.push((grip.handle, adjacent_id, GripApply::Absolute(point))); + } + } + edits.push((grip.handle, grip.grip_id, GripApply::Absolute(snapped))); + edits + } else if menu_action.is_some() { Vec::new() } else { grip.targets diff --git a/src/app/view/mod.rs b/src/app/view/mod.rs index 3e31f3d60..751e72d11 100644 --- a/src/app/view/mod.rs +++ b/src/app/view/mod.rs @@ -1004,6 +1004,44 @@ bg={bg_ms:.1}ms n={view_count}" w, ) }); + let rectangle_values = tab + .active_grip + .as_ref() + .and_then(|grip| grip.rectangle_frame) + .map(|(opposite, width_axis, height_axis)| { + let delta = w - opposite; + (delta.dot(width_axis).abs(), delta.dot(height_axis).abs()) + }); + let rectangle_label_screens = tab + .active_grip + .as_ref() + .and_then(|grip| grip.rectangle_frame) + .and_then(|(opposite, width_axis, height_axis)| { + let delta = w - opposite; + let width = delta.dot(width_axis); + let height = delta.dot(height_axis); + let width_center = opposite + width_axis * (width * 0.5); + let height_center = opposite + + width_axis * width + + height_axis * (height * 0.5); + let (vw, vh) = tab.scene.selection.borrow().vp_size; + let (camera, bounds) = tab + .scene + .viewport_edit_frame((vw, vh)) + .unwrap_or_else(|| { + ( + tab.scene.camera.borrow().clone(), + tab.scene.active_model_tile_bounds(vw, vh), + ) + }); + let project = |point| { + camera.project(point, bounds).map(|screen| iced::Point::new( + bounds.x + screen.x, + bounds.y + screen.y, + )) + }; + Some((project(width_center)?, project(height_center)?)) + }); let boxes: Vec = tab .dyn_fields .iter() @@ -1011,6 +1049,14 @@ bg={bg_ms:.1}ms n={view_count}" .map(|(idx, f)| { let value = match (&f.buffer, live) { (Some(b), _) => b.clone(), + (None, _) if rectangle_values.is_some() => { + let (width, height) = rectangle_values.unwrap(); + match f.role { + crate::command::DynRole::Width => format!("{width:.4}"), + crate::command::DynRole::Height => format!("{height:.4}"), + _ => String::new(), + } + } // An angle step with a command-supplied live value // (ARC span / direction) shows it in degrees. (None, Some(lv)) if f.component == DynComponent::Angle => { @@ -1039,6 +1085,13 @@ bg={bg_ms:.1}ms n={view_count}" active: idx == tab.dyn_active, locked: f.locked(), role: f.role, + center: rectangle_label_screens.and_then(|(width, height)| { + match f.role { + crate::command::DynRole::Width => Some(width), + crate::command::DynRole::Height => Some(height), + _ => None, + } + }), } }) .collect(); diff --git a/src/entities/lwpolyline.rs b/src/entities/lwpolyline.rs index c5b2a8dac..21adcede0 100644 --- a/src/entities/lwpolyline.rs +++ b/src/entities/lwpolyline.rs @@ -885,16 +885,6 @@ fn set_revision_cloud_arc_length(pline: &mut LwPolyline, requested: f64) { } pub(crate) fn is_rectangle(pline: &LwPolyline) -> bool { - if pline.common.extended_data.get_record("OCS_RECTANGLE").is_some() { - return true; - } - is_resizable_rectangle(pline) -} - -/// Geometry check used for constrained rectangle grips. Unlike the semantic -/// marker, this must stop matching as soon as an unrestricted vertex edit has -/// distorted the four-corner rectangle. -fn is_resizable_rectangle(pline: &LwPolyline) -> bool { if !pline.is_closed || pline.vertices.len() != 4 || pline.vertices.iter().any(|vertex| vertex.bulge.abs() > 1.0e-9) @@ -918,6 +908,11 @@ fn is_resizable_rectangle(pline: &LwPolyline) -> bool { && edges[1].cross(edges[3]).abs() <= tolerance * lengths[1] * lengths[3] } +fn is_rectangle_command_entity(pline: &LwPolyline) -> bool { + pline.common.extended_data.get_record("OCS_RECTANGLE").is_some() + || is_rectangle(pline) +} + fn properties(pline: &LwPolyline) -> Vec { let n = pline.vertices.len(); // The panel's Current Vertex focus, clamped to this polyline's range. @@ -978,7 +973,7 @@ fn properties(pline: &LwPolyline) -> Vec { edit(t!("Vertex Y").as_ref(), "vertex_y", vy), edit_scalar(t!("Bulge").as_ref(), "bulge", v.map_or(0.0, |vertex| vertex.bulge)), ]; - if !is_rectangle(pline) { + if !is_rectangle_command_entity(pline) { geometry_props.push(edit(t!("Start segment width").as_ref(), "start_width", start_w)); geometry_props.push(edit(t!("End segment width").as_ref(), "end_width", end_w)); } @@ -1210,7 +1205,14 @@ impl crate::entities::traits::Grippable for LwPolyline { // Vertex grip. Break only where a split is possible: any vertex // of a closed polyline, interior vertices of an open one. let breakable = n >= 3 && (self.is_closed || (grip_id > 0 && grip_id < n - 1)); - let mut items = vec![ + let mut items = Vec::new(); + if is_rectangle(self) { + items.push(GripMenuItem { + label: "Resize", + action: GripMenuAction::RectangleResize, + }); + } + items.extend([ GripMenuItem { label: "Stretch", action: GripMenuAction::Stretch, @@ -1223,7 +1225,7 @@ impl crate::entities::traits::Grippable for LwPolyline { label: "Remove Vertex", action: GripMenuAction::RemoveVertex, }, - ]; + ]); if breakable { items.push(GripMenuItem { label: "Break", @@ -1250,7 +1252,7 @@ impl crate::entities::traits::Grippable for LwPolyline { } }; let mut items = Vec::new(); - if is_resizable_rectangle(self) && seg < 4 { + if is_rectangle(self) && seg < 4 { // Moving an edge changes the dimension perpendicular to it. items.push(GripMenuItem { label: if seg % 2 == 0 { "Height" } else { "Width" }, @@ -1282,7 +1284,7 @@ impl crate::entities::traits::Grippable for LwPolyline { ) -> Option<&'static str> { use crate::scene::model::object::GripMenuAction as A; let n = self.vertices.len(); - (is_resizable_rectangle(self) + (is_rectangle(self) && n == 4 && (n..n + 4).contains(&grip_id) && matches!(action, A::RectangleWidth | A::RectangleHeight)) @@ -1299,7 +1301,7 @@ impl crate::entities::traits::Grippable for LwPolyline { point: glam::DVec3, ) -> Option { use crate::scene::model::object::GripMenuAction as A; - if !is_resizable_rectangle(self) + if !is_rectangle(self) || !matches!(action, A::RectangleWidth | A::RectangleHeight) { return None; @@ -1334,7 +1336,7 @@ impl crate::entities::traits::Grippable for LwPolyline { value: f64, ) { use crate::scene::model::object::GripMenuAction as A; - if !is_resizable_rectangle(self) || value <= 1.0e-9 + if !is_rectangle(self) || value <= 1.0e-9 || !matches!(action, A::RectangleWidth | A::RectangleHeight) { return; @@ -1582,6 +1584,14 @@ mod tests { assert_eq!(right[1].action, GripMenuAction::Stretch); } + #[test] + fn rectangle_corner_offers_resize_before_stretch() { + let pl = make_test_rectangle(); + let corner = pl.grip_menu(0); + assert_eq!(corner[0].action, GripMenuAction::RectangleResize); + assert_eq!(corner[1].action, GripMenuAction::Stretch); + } + #[test] fn rectangle_dimension_edit_keeps_opposite_edge_fixed() { let mut pl = make_test_rectangle(); @@ -1590,7 +1600,7 @@ mod tests { assert_eq!(pl.vertices[1].location, Vector2::new(10.0, 0.0)); assert_eq!(pl.vertices[2].location, Vector2::new(10.0, 8.0)); assert_eq!(pl.vertices[3].location, Vector2::new(0.0, 8.0)); - assert!(is_resizable_rectangle(&pl)); + assert!(is_rectangle(&pl)); } #[test] diff --git a/src/scene/model/object.rs b/src/scene/model/object.rs index 34e539b6c..8a6079de5 100644 --- a/src/scene/model/object.rs +++ b/src/scene/model/object.rs @@ -177,6 +177,7 @@ pub enum GripMenuAction { ArcLength, RectangleWidth, RectangleHeight, + RectangleResize, AddVertex, RemoveVertex, ConvertToArc, diff --git a/src/scene/pick/grip.rs b/src/scene/pick/grip.rs index 757c1496e..f8f76e080 100644 --- a/src/scene/pick/grip.rs +++ b/src/scene/pick/grip.rs @@ -48,6 +48,8 @@ pub struct GripEdit { pub axis: Option, /// Every hot grip moved by this edit. A normal grip edit contains one target. pub targets: Vec, + /// Opposite corner and local width/height axes for rectangle corner resize. + pub rectangle_frame: Option<(DVec3, DVec3, DVec3)>, } #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -58,6 +60,7 @@ pub enum GripEditMode { ArcLength, RectangleWidth, RectangleHeight, + RectangleResize, } #[derive(Clone, Debug)] @@ -88,6 +91,7 @@ impl GripEdit { is_translate, last_world: world, }], + rectangle_frame: None, } } @@ -120,6 +124,20 @@ impl GripEdit { edit.mode = GripEditMode::RectangleHeight; edit } + + pub fn rectangle_resize( + handle: Handle, + grip_id: usize, + world: DVec3, + opposite: DVec3, + width_axis: DVec3, + height_axis: DVec3, + ) -> Self { + let mut edit = Self::single(handle, grip_id, false, world); + edit.mode = GripEditMode::RectangleResize; + edit.rectangle_frame = Some((opposite, width_axis, height_axis)); + edit + } } // ── Screen-space helpers ─────────────────────────────────────────────────── diff --git a/src/ui/overlay.rs b/src/ui/overlay.rs index 113057a8d..b05381b2c 100644 --- a/src/ui/overlay.rs +++ b/src/ui/overlay.rs @@ -2685,6 +2685,8 @@ pub struct DynBox { /// User has typed a value (the box no longer tracks the cursor). pub locked: bool, pub role: DynRole, + /// Optional exact viewport position, used by rotated rectangle dimensions. + pub center: Option, } pub fn dynamic_input_overlay<'a>( @@ -3038,7 +3040,7 @@ impl DynInputCanvas { // ── Box placement by role ── for b in &self.boxes { - let center = match b.role { + let center = b.center.unwrap_or_else(|| match b.role { DynRole::Angle => self.label_screen.unwrap_or_else(|| { let a_mid = a_ref + sweep * 0.5; let r = (len - DYN_BOX_H * 2.0).max(len * 0.5); @@ -3071,7 +3073,7 @@ impl DynInputCanvas { x: base.x + dx * len * 0.5 + nx * 16.0, y: base.y + dy * len * 0.5 + ny * 16.0, }, - }; + }); Self::draw_box(frame, b, center, bounds, theme); } // Keep the tracking hint near the crosshair in guided layouts.