Measure: drag the labels away from the part (#8510) (#9395)

* claim: #8510

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Measure: drag the labels away from the part (#8510)

The distance and X/Y/Z labels in the view follow a drag of the pointer and keep
a leader to what they measure; a double-click or a new measurement puts them
back. A press on a label picks nothing, starts no box selection and opens no
Select Other.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
PaddleStroke
2026-10-31 02:00:23 +00:00
committed by GitHub
parent cce337f83f
commit 3877ef08b9
5 changed files with 184 additions and 14 deletions
+113 -12
View File
@@ -287,6 +287,7 @@ pub(crate) fn owns_pointer(app: &SolveApp, proj: &Proj, p: Pos2) -> bool {
&& app.tool.is_none()
&& crate::browser::occurrence_triad_model(app).is_some_and(|t| crate::gizmo::contains_pointer(proj, &t, p)))
|| crate::place_gizmo::contains_pointer(app, p)
|| app.dialog.as_ref().is_some_and(|d| matches!(&d.kind, Kind::Measure { labels, .. } if labels.contains(p)))
}
/// Draw the manipulator and the value box (called by the viewport after the model is drawn).
@@ -308,10 +309,16 @@ pub fn show(app: &mut SolveApp, ui: &mut egui::Ui, painter: &egui::Painter, proj
app.dialog = Some(d);
return;
}
if let Kind::Measure { result: Some(r), show, .. } = &d.kind {
measure_line(app, painter, proj, r, *show);
app.dialog = Some(d);
return;
if let Kind::Measure { result, show, labels, .. } = &mut d.kind {
labels.drawn = Default::default();
if !ui.input(|i| i.pointer.primary_down()) {
labels.grab = None;
}
if let Some(r) = result {
measure_line(app, ui, painter, proj, r, *show, labels);
app.dialog = Some(d);
return;
}
}
// Move: the triad at the pivot; dragging it sets the distances and angles. Its value box
// sits beside it and reads the move's main value, so a drag shows its number and typing
@@ -1300,9 +1307,85 @@ fn radius_spline_handles(app: &SolveApp, ui: &mut egui::Ui, painter: &egui::Pain
true
}
/// The Measure labels in the view the user dragged away from the part (#8510): the distance's,
/// then X, Y and Z's. They last while the measurement does; another one starts them over.
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct MeasureLabels {
/// How far each label was dragged from its own place, in points.
offset: [egui::Vec2; 4],
/// Where each was drawn in the last frame, so a press on one drags it instead of picking
/// under it or navigating.
drawn: [Option<egui::Rect>; 4],
/// The dragged label's offset when the button went down (while it is held).
grab: Option<egui::Vec2>,
}
impl MeasureLabels {
/// Whether `p` is on one of the labels drawn in the last frame.
pub(crate) fn contains(&self, p: Pos2) -> bool {
self.drawn.iter().flatten().any(|r| r.contains(p))
}
/// How far label `i` was dragged (zero: in its own place).
pub(crate) fn offset(&self, i: usize) -> egui::Vec2 {
self.offset.get(i).copied().unwrap_or(egui::Vec2::ZERO)
}
}
/// Label `i`, drawn at `rect`, follows a drag of the pointer; a double-click puts it back.
fn drag_label(ui: &mut egui::Ui, labels: &mut MeasureLabels, i: usize, rect: egui::Rect) {
if let Some(drawn) = labels.drawn.get_mut(i) {
*drawn = Some(rect);
}
let r = ui.interact(rect, egui::Id::new(("sc_measure_label", i)), egui::Sense::click_and_drag());
if r.dragged() {
ui.ctx().set_cursor_icon(egui::CursorIcon::Grabbing);
} else if r.hovered() {
ui.ctx().set_cursor_icon(egui::CursorIcon::Grab);
}
let Some(offset) = labels.offset.get_mut(i) else { return };
if r.double_clicked() {
*offset = egui::Vec2::ZERO;
} else if r.dragged()
&& let (Some(from), Some(to)) = (ui.input(|i| i.pointer.press_origin()), r.interact_pointer_pos())
{
// Where it was at the press, plus how far the pointer went since: the label stays under
// the pointer where it was grabbed.
let start = *labels.grab.get_or_insert(*offset);
let moved = start + (to - from);
// Far enough to leave any view, finite whatever the pointer reports.
if moved.is_finite() {
*offset = moved.clamp(egui::Vec2::splat(-10_000.0), egui::Vec2::splat(10_000.0));
}
}
}
/// `rect` moved by a dragged label's `offset`, kept inside the view so it can be dragged back.
fn moved_label(proj: &Proj, rect: egui::Rect, offset: egui::Vec2) -> egui::Rect {
if offset == egui::Vec2::ZERO {
return rect;
}
let bounds = proj.rect.shrink(4.0);
let moved = rect.translate(offset);
let min = egui::pos2(
moved.left().clamp(bounds.left(), (bounds.right() - rect.width()).max(bounds.left())),
moved.top().clamp(bounds.top(), (bounds.bottom() - rect.height()).max(bounds.top())),
);
egui::Rect::from_min_size(min, rect.size())
}
/// The measured distance: a line between the ends of the shown measure (the centres for
/// centre to centre, the closest or farthest points) with its length.
fn measure_line(app: &SolveApp, painter: &egui::Painter, proj: &Proj, r: &serde_json::Value, show: Option<crate::dialogs::Shown>) {
/// centre to centre, the closest or farthest points) with its length. Its labels can be dragged
/// away from the part; a moved one keeps a leader to what it measures.
fn measure_line(
app: &SolveApp,
ui: &mut egui::Ui,
painter: &egui::Painter,
proj: &Proj,
r: &serde_json::Value,
show: Option<crate::dialogs::Shown>,
labels: &mut MeasureLabels,
) {
let t = Tokens::get();
let Some((_, d, a, b)) = crate::dialogs::shown_distance(r, show) else { return };
if !a.is_finite() || !b.is_finite() || !d.is_finite() {
@@ -1317,15 +1400,20 @@ fn measure_line(app: &SolveApp, painter: &egui::Painter, proj: &Proj, r: &serde_
painter.circle(s, 3.5, t.manipulator, Stroke::new(1.0, Color32::WHITE));
}
pick_numbers(painter, sa, sb);
let mid = sa + (sb - sa) * 0.5 + vec2(10.0, -14.0);
let mid = sa + (sb - sa) * 0.5;
let galley = painter.layout_no_wrap(crate::prefs::show_mm(app, d, 1), egui::FontId::proportional(crate::theme::Tokens::get().font_label), t.text);
let rect = egui::Rect::from_min_size(mid, galley.size() + vec2(10.0, 6.0));
let own = egui::Rect::from_min_size(mid + vec2(10.0, -14.0), galley.size() + vec2(10.0, 6.0));
let rect = moved_label(proj, own, labels.offset(0));
crate::scenario::publish_target("measure:label", rect);
if app.preferences.measure_axis_distances {
measure_components(app, painter, proj, a, b, rect);
measure_components(app, ui, painter, proj, a, b, rect, labels);
}
if rect != own {
painter.line_segment([mid, rect.clamp(mid)], Stroke::new(1.0, t.manipulator));
}
painter.rect(rect, t.radius_sm.saturating_sub(1), t.overlay, t.control_border_stroke(t.border), egui::StrokeKind::Inside);
painter.galley(rect.min + vec2(5.0, 3.0), galley, t.text);
drag_label(ui, labels, 0, rect);
}
/// "1" and "2" beside the measured line's ends (#6020), as the panel lists the picks: each just
@@ -1347,13 +1435,24 @@ fn pick_numbers(painter: &egui::Painter, sa: Pos2, sb: Pos2) {
}
/// A world-axis-aligned chain between the same two measured points. Zero-length and
/// view-aligned legs still get a label; labels move apart when their projections coincide.
fn measure_components(app: &SolveApp, painter: &egui::Painter, proj: &Proj, a: Vec3, b: Vec3, total: egui::Rect) {
/// view-aligned legs still get a label; labels move apart when their projections coincide, and
/// the user can drag each away (`labels` 1 to 3).
#[allow(clippy::too_many_arguments)]
fn measure_components(
app: &SolveApp,
ui: &mut egui::Ui,
painter: &egui::Painter,
proj: &Proj,
a: Vec3,
b: Vec3,
total: egui::Rect,
labels: &mut MeasureLabels,
) {
let t = Tokens::get();
let x = Vec3::new(b.x, a.y, a.z);
let y = Vec3::new(b.x, b.y, a.z);
let mut occupied = vec![total];
for (axis, start, end, color) in [("x", a, x, t.axis_x), ("y", x, y, t.axis_y), ("z", y, b, t.axis_z)] {
for (i, (axis, start, end, color)) in [("x", a, x, t.axis_x), ("y", x, y, t.axis_y), ("z", y, b, t.axis_z)].into_iter().enumerate() {
let color = color.lerp_to_gamma(t.text, 0.25);
let distance = start.dist(end);
if !distance.is_finite() {
@@ -1401,12 +1500,14 @@ fn measure_components(app: &SolveApp, painter: &egui::Painter, proj: &Proj, a: V
}
}
}
let rect = moved_label(proj, rect, labels.offset(i + 1));
painter.line_segment([at, rect.center()], Stroke::new(0.8, color));
painter.rect(rect, t.radius_sm.saturating_sub(1), t.overlay, Stroke::new(1.0, color), egui::StrokeKind::Inside);
painter.galley(rect.min + vec2(5.0, 3.0), galley, t.text);
let handle = format!("measure:label:{axis}");
crate::scenario::publish_target(&handle, rect);
occupied.push(rect);
drag_label(ui, labels, i + 1, rect);
}
}
+6 -2
View File
@@ -302,6 +302,8 @@ crate::dialog_descriptor::dialog_descriptors! {
/// The measure chosen in the panel (centre, min or max); `None` follows the result's
/// own default (centre where a round item gives one).
show: Option<Shown>,
/// Where the labels in the view were dragged to (#8510).
labels: crate::canvas::MeasureLabels,
},
/// Move bodies by a distance along X, Y and Z.
/// Move/Copy (see `dialogs_move`): the move type, X/Y/Z distances (Point to Position: the
@@ -929,7 +931,7 @@ impl Dialog {
vec![SelInput::new("Plane", PLANES | PLANAR_FACES, false)],
),
"inspect.measure" => Dialog::new(
Kind::Measure { result: None, of: Vec::new(), show: None },
Kind::Measure { result: None, of: Vec::new(), show: None, labels: Default::default() },
vec![SelInput::new(
"Items",
FACES
@@ -2916,9 +2918,11 @@ pub(crate) fn fill_cells(st: &solidcraft_engine::doc::ModelState, tools: &[Strin
/// Measure again when the picked items changed.
fn update_measure(app: &SolveApp, d: &mut Dialog) {
let items: Vec<Sel> = sels(d, 0).to_vec();
if let Kind::Measure { result, of, .. } = &mut d.kind
if let Kind::Measure { result, of, labels, .. } = &mut d.kind
&& *of != items
{
// Another measurement: its labels start in their own places.
*labels = Default::default();
*result = if items.is_empty() { None } else { Some(app.session.measure_items(&items)) };
*of = items;
}
@@ -210,6 +210,65 @@ fn the_view_numbers_the_two_picks() {
}
}
/// The labels in the view can be dragged away from the part (#8510): each follows the pointer,
/// keeps a leader to what it measures, picks nothing and starts no box selection on the way, and
/// goes back to its own place on a double-click or with the next measurement.
#[test]
fn the_measure_labels_drag_away_from_the_part_and_back() {
let mut h = vertex_measurement([0., 0., 0.], [-3., 4., -12.]);
h.call("ui.view", json!({"view": "iso"}));
painted_text(&mut h);
let own = component_rects();
let measurement = result(&h).clone();
let picks = h.call("ui.selection", json!({}))["result"].clone();
let drag = |h: &mut Harness, from: egui::Pos2, by: egui::Vec2| {
h.call("ui.drag", json!({"x0": from.x, "y0": from.y, "x1": from.x + by.x, "y1": from.y + by.y, "steps": 6}));
painted_text(h);
};
// The distance, then the Z part, each dragged by the grabbed point away from the part.
for (i, by) in [(0, egui::vec2(180.0, -130.0)), (3, egui::vec2(-160.0, 90.0))] {
let from = component_rects()[i].left_top() + egui::vec2(6.0, 4.0);
let before = component_rects();
drag(&mut h, from, by);
let after = component_rects();
let moved = after[i].min - before[i].min;
assert!((moved - by).length() < 1.0, "label {i} follows the pointer: moved {moved:?}, dragged {by:?}");
if i == 3 {
assert_eq!(after[..3], before[..3], "only the dragged label moves");
}
assert_eq!(*result(&h), measurement, "dragging a label measures nothing new");
assert_eq!(h.call("ui.selection", json!({}))["result"], picks, "dragging a label picks nothing");
assert!(h.app.viewport.boxsel.is_none(), "dragging a label starts no box selection");
}
let dragged = component_rects();
assert!(!dragged[0].intersects(own[0]), "the distance left its place over the part: {:?} vs {:?}", dragged[0], own[0]);
// The view turns: a dragged label stays away from the line by the same amount.
h.call("ui.view", json!({"view": "front"}));
painted_text(&mut h);
let turned = component_rects();
h.call("ui.view", json!({"view": "iso"}));
painted_text(&mut h);
assert_eq!(component_rects()[0], dragged[0], "back in the same view, back in the same place");
assert!(turned.iter().all(|r| r.is_finite()));
// A double-click puts the distance back.
let at = dragged[0].center();
h.call("ui.click", json!({"x": at.x, "y": at.y, "double": true}));
painted_text(&mut h);
assert_eq!(component_rects()[0], own[0], "a double-click puts the label back");
// Another measurement puts the Z part back too.
let offsets = |h: &Harness| match &h.app.dialog.as_ref().unwrap().kind {
Kind::Measure { labels, .. } => (0..4).map(|i| labels.offset(i)).collect::<Vec<_>>(),
_ => panic!("expected the Measure dialog"),
};
assert_ne!(offsets(&h)[3], egui::Vec2::ZERO);
if let Some(input) = h.app.dialog.as_mut().and_then(|d| d.inputs.first_mut()) {
input.items = [[0., 0., 0.], [-3., 4., 0.]].into_iter().map(|p| Sel::Vertex { body: "Box".into(), point: p.into() }).collect();
}
painted_text(&mut h);
assert!((result(&h)["distance_mm"].as_f64().unwrap() - 5.).abs() < 1e-8, "measured the new picks");
assert!(offsets(&h).iter().all(|o| *o == egui::Vec2::ZERO), "{:?}", offsets(&h));
}
#[test]
fn the_distance_row_has_a_copy_button_that_copies_the_shown_value() {
let mut h = vertex_measurement([0., 0., 0.], [3., 4., 0.]);
+3
View File
@@ -422,6 +422,9 @@ Measure shows the currently selected distance (centre, minimum or maximum) and s
distances on the canvas. The component dimensions follow the world axes and remain visible
until the Measure dialog closes. To hide these extra lines and labels, turn off
**Preferences > Graphics > Show X/Y/Z distances**. The choice is saved between runs.
Drag the distance or an X, Y or Z label to move it away from the part; a moved label keeps a
line to what it measures. Double-click a label to put it back. Measuring other items starts the
labels in their own places again.
### Reviewing mirror, pattern, and offset results
+3
View File
@@ -355,6 +355,9 @@ to hide them while keeping the total distance and the dialog's ΔX/ΔY/ΔZ value
overlays remain visible until Measure closes.
Overlay handles `measure:label:x`, `measure:label:y` and `measure:label:z` identify the extra
labels; `prefs:measure_axis_distances` identifies the checkbox.
A `ui.drag` from `measure:label` or one of the axis labels moves that label (screen offset, kept
while the measured items stay the same; a double-click puts it back). It picks nothing and starts
no box selection.
## UI