Sketch dimensions drawn as dimensions: extension lines, dimension lines and arcs with arrowheads (flipped outside when tight), the value centred on the line (fx: for expressions), R/Ø leaders, angle arcs, arc-length mark, driven ones in parentheses in a muted colour; click selects, Delete removes, drag moves the text (sketch.dimension_text, kept relative to the dimension), double-click edits the value in place with parameter completion
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AS5Tn3xieewUSg3uxrMVdL
This commit is contained in:
bherbruckandClaude Opus 5.5 committed
1 parent
4adfd69d6a
commit
187ffd0a03
12 files changed
+946
-57
No files matched your search
@@ -0,0 +1,346 @@
|
||||
//! Sketch dimensions drawn as dimensions: extension lines from the measured geometry, a
|
||||
//! dimension line (or arc) with arrowheads, and the value centred on it; radius and diameter
|
||||
//! leaders with R / Ø, angles as an arc between the two lines, arc lengths with the arc mark,
|
||||
//! driven (reference) dimensions in parentheses in a muted colour. The geometry comes from
|
||||
//! `solvecraft_sketch::dim_layout`.
|
||||
//!
|
||||
//! A click selects a dimension (Delete removes it), a drag moves its text (and so the offset of
|
||||
//! its dimension line), a double-click edits its value in place with parameter completion.
|
||||
//! Everything acts through commands: `sketch.dimension_text`, `sketch.delete`,
|
||||
//! `ChangeParameterCommand`.
|
||||
|
||||
use std::cell::RefCell;
|
||||
|
||||
use egui::{FontId, Pos2, Rect, Shape, Stroke, vec2};
|
||||
use serde_json::json;
|
||||
use solvecraft_engine::geom::Vec2;
|
||||
use solvecraft_engine::sketch::{ConstraintKind, DimFrame, chain_centres, default_text, dim_frame, dim_layout};
|
||||
|
||||
use crate::SolveApp;
|
||||
use crate::theme::Tokens;
|
||||
use crate::viewport::Proj;
|
||||
|
||||
/// A dimension as drawn this frame (screen space), for hit testing.
|
||||
#[derive(Clone, Debug)]
|
||||
struct Drawn {
|
||||
id: String,
|
||||
param: Option<String>,
|
||||
text: Rect,
|
||||
segs: Vec<[Pos2; 2]>,
|
||||
/// Text centre in sketch coordinates.
|
||||
at: Vec2,
|
||||
}
|
||||
|
||||
/// The inline value editor: parameter, expression, where it sits, first frame.
|
||||
#[derive(Clone, Debug)]
|
||||
struct Edit {
|
||||
param: String,
|
||||
expr: String,
|
||||
at: Pos2,
|
||||
/// Frames left in which the box (re)takes the keyboard: the rest of the double-click
|
||||
/// that opened it must not close it.
|
||||
fresh: u8,
|
||||
}
|
||||
|
||||
thread_local! {
|
||||
static DRAWN: RefCell<Vec<Drawn>> = const { RefCell::new(Vec::new()) };
|
||||
static SELECTED: RefCell<Option<String>> = const { RefCell::new(None) };
|
||||
/// A text being dragged: dimension id, undo depth at the start, grab offset (sketch).
|
||||
static DRAG: RefCell<Option<(String, usize, Vec2)>> = const { RefCell::new(None) };
|
||||
static EDIT: RefCell<Option<Edit>> = const { RefCell::new(None) };
|
||||
}
|
||||
|
||||
/// Frames the inline editor holds on to the keyboard after opening.
|
||||
const FRESH: u8 = 3;
|
||||
|
||||
/// Pixels from a dimension line or the text box that still count as on it.
|
||||
const HIT_PX: f32 = 4.0;
|
||||
|
||||
fn seg_dist(p: Pos2, a: Pos2, b: Pos2) -> f32 {
|
||||
let ab = b - a;
|
||||
let t = if ab.length_sq() > 0.0 { ((p - a).dot(ab) / ab.length_sq()).clamp(0.0, 1.0) } else { 0.0 };
|
||||
p.distance(a + ab * t)
|
||||
}
|
||||
|
||||
/// The dimension under a screen position (its id).
|
||||
pub fn hit(pos: Pos2) -> Option<String> {
|
||||
DRAWN.with(|d| {
|
||||
let d = d.borrow();
|
||||
// Text boxes first (they sit on top of the lines), then the lines.
|
||||
d.iter()
|
||||
.find(|x| x.text.expand(2.0).contains(pos))
|
||||
.or_else(|| d.iter().find(|x| x.segs.iter().any(|s| seg_dist(pos, s[0], s[1]) <= HIT_PX)))
|
||||
.map(|x| x.id.clone())
|
||||
})
|
||||
}
|
||||
|
||||
/// The selected dimension (constraint id).
|
||||
pub fn selected() -> Option<String> {
|
||||
SELECTED.with(|s| s.borrow().clone())
|
||||
}
|
||||
|
||||
/// A click without a tool: select the dimension under it (true: the click was used). A click
|
||||
/// elsewhere drops the dimension selection.
|
||||
pub fn click(app: &mut SolveApp, pos: Pos2) -> bool {
|
||||
if app.session.active_sketch.is_none() {
|
||||
return false;
|
||||
}
|
||||
let h = hit(pos);
|
||||
SELECTED.with(|s| *s.borrow_mut() = h.clone());
|
||||
if let Some(id) = &h {
|
||||
let _ = app.run("select.clear", json!({}));
|
||||
app.set_status(format!("Dimension {id} selected: drag to move, double-click to edit, Delete removes it"), false);
|
||||
}
|
||||
h.is_some()
|
||||
}
|
||||
|
||||
/// Drop the dimension selection (true when there was one).
|
||||
pub fn deselect() -> bool {
|
||||
SELECTED.with(|s| s.borrow_mut().take()).is_some()
|
||||
}
|
||||
|
||||
/// Delete the selected dimension (true when one was selected).
|
||||
pub fn delete_selected(app: &mut SolveApp) -> bool {
|
||||
let Some(id) = SELECTED.with(|s| s.borrow_mut().take()) else { return false };
|
||||
let _ = app.run("sketch.delete", json!({"entities": [id]}));
|
||||
true
|
||||
}
|
||||
|
||||
/// A double-click on a dimension opens its value for editing (true: it was on one).
|
||||
pub fn double_click(app: &mut SolveApp, pos: Pos2) -> bool {
|
||||
let Some(d) = DRAWN.with(|d| {
|
||||
let id = hit(pos)?;
|
||||
d.borrow().iter().find(|x| x.id == id).cloned()
|
||||
}) else {
|
||||
return false;
|
||||
};
|
||||
SELECTED.with(|s| *s.borrow_mut() = Some(d.id.clone()));
|
||||
let Some(param) = d.param else {
|
||||
app.set_status("A driven dimension measures the sketch; it has no value to edit", false);
|
||||
return true;
|
||||
};
|
||||
let expr = app.session.doc.param(¶m).map(|p| p.expr.clone()).unwrap_or_default();
|
||||
EDIT.with(|e| *e.borrow_mut() = Some(Edit { param, expr, at: d.text.center(), fresh: FRESH }));
|
||||
true
|
||||
}
|
||||
|
||||
/// Start dragging the text of the dimension under `press` (true: a dimension took the drag).
|
||||
pub fn drag_start(app: &SolveApp, press: Pos2, press_sketch: Vec2) -> bool {
|
||||
let Some(d) = DRAWN.with(|d| {
|
||||
let id = hit(press)?;
|
||||
d.borrow().iter().find(|x| x.id == id).cloned()
|
||||
}) else {
|
||||
return false;
|
||||
};
|
||||
SELECTED.with(|s| *s.borrow_mut() = Some(d.id.clone()));
|
||||
DRAG.with(|g| *g.borrow_mut() = Some((d.id, app.session.undo.len(), d.at - press_sketch)));
|
||||
true
|
||||
}
|
||||
|
||||
/// Is a dimension text being dragged?
|
||||
pub fn dragging() -> bool {
|
||||
DRAG.with(|g| g.borrow().is_some())
|
||||
}
|
||||
|
||||
/// Move the dragged text so it follows the pointer (at `to`, sketch coordinates); one undo
|
||||
/// step for the whole drag.
|
||||
pub fn drag_to(app: &mut SolveApp, to: Vec2) {
|
||||
let Some((id, depth, off)) = DRAG.with(|g| g.borrow().clone()) else { return };
|
||||
let at = to + off;
|
||||
if app.session.execute("sketch.dimension_text", &json!({"dimension": id, "at": [at.x, at.y]})).is_ok() {
|
||||
app.session.undo.truncate(depth + 1);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn drag_end() {
|
||||
DRAG.with(|g| *g.borrow_mut() = None);
|
||||
}
|
||||
|
||||
/// The text shown for a dimension: the value (R / Ø for radius and diameter, degrees for
|
||||
/// angles), "fx: value" when an expression drives it, in parentheses when driven.
|
||||
pub fn label(k: &ConstraintKind, expr: Option<&str>, driven: bool) -> String {
|
||||
let v = k.value().unwrap_or(0.0);
|
||||
let num = if k.is_angle() { format!("{:.1}°", v.to_degrees()) } else { format!("{v:.2}") };
|
||||
let num = match k {
|
||||
ConstraintKind::Radius { .. } => format!("R{num}"),
|
||||
ConstraintKind::Diameter { .. } | ConstraintKind::LinearDiameter { .. } => format!("Ø{num}"),
|
||||
_ => num,
|
||||
};
|
||||
let plain = expr.is_none_or(|e| {
|
||||
let e = e.trim();
|
||||
let e = e.strip_suffix("mm").or_else(|| e.strip_suffix("deg")).or_else(|| e.strip_suffix('°')).unwrap_or(e);
|
||||
e.trim().parse::<f64>().is_ok()
|
||||
});
|
||||
let text = if plain { num } else { format!("fx: {num}") };
|
||||
if driven { format!("({text})") } else { text }
|
||||
}
|
||||
|
||||
/// Draw the active sketch's dimensions and remember where they are for picking.
|
||||
pub fn show(app: &mut SolveApp, ui: &egui::Ui, painter: &egui::Painter, proj: &Proj) {
|
||||
let mut drawn = Vec::new();
|
||||
let st = app.session.model.state();
|
||||
let Some(ss) = app.session.active_sketch.and_then(|s| st.sketch(s)) else {
|
||||
DRAWN.with(|d| d.borrow_mut().clear());
|
||||
SELECTED.with(|s| *s.borrow_mut() = None);
|
||||
EDIT.with(|e| *e.borrow_mut() = None);
|
||||
return;
|
||||
};
|
||||
let sk = &ss.sketch;
|
||||
let tk = Tokens::get();
|
||||
let sel = selected();
|
||||
// A selected dimension that was deleted (undo, another command) is forgotten.
|
||||
if sel.as_ref().is_some_and(|id| !sk.constraints.iter().any(|c| &c.id == id)) {
|
||||
SELECTED.with(|s| *s.borrow_mut() = None);
|
||||
}
|
||||
let hover = ui.input(|i| i.pointer.hover_pos()).filter(|p| proj.rect.contains(*p)).and_then(hit);
|
||||
let to = |p: Vec2| proj.to_screen(ss.plane.to_world(p));
|
||||
let font = FontId::proportional(12.0);
|
||||
let centres = chain_centres(sk);
|
||||
for c in &sk.constraints {
|
||||
let Some(frame) = dim_frame(sk, &c.kind) else { continue };
|
||||
let anchor = match frame {
|
||||
DimFrame::Linear { p0, p1, .. } => (p0 + p1) * 0.5,
|
||||
DimFrame::Radial { center, .. } | DimFrame::ArcLength { center, .. } => center,
|
||||
DimFrame::Angular { vertex, .. } => vertex,
|
||||
};
|
||||
// Millimetres per pixel at the dimension.
|
||||
let (Some(a), Some(b)) = (to(anchor), to(anchor + Vec2::X)) else { continue };
|
||||
let px = 1.0 / f64::from(a.distance(b)).max(1e-9);
|
||||
if !px.is_finite() {
|
||||
continue;
|
||||
}
|
||||
let expr = c.param.as_ref().and_then(|p| app.session.doc.param(p)).map(|p| p.expr.as_str());
|
||||
let failing = ss.report.failing.contains(&c.id);
|
||||
let col = if failing {
|
||||
tk.error
|
||||
} else if sel.as_deref() == Some(c.id.as_str()) || hover.as_deref() == Some(c.id.as_str()) {
|
||||
tk.accent
|
||||
} else if c.driven {
|
||||
tk.dimension_driven
|
||||
} else {
|
||||
tk.dimension
|
||||
};
|
||||
let galley = painter.layout_no_wrap(label(&c.kind, expr, c.driven), font.clone(), col);
|
||||
let size = galley.size() + vec2(6.0, 2.0);
|
||||
let half = Vec2::new(f64::from(size.x) * 0.5 * px, f64::from(size.y) * 0.5 * px);
|
||||
// Unplaced linear dimensions sit outside the shape they measure.
|
||||
let away = first_point(sk, &c.kind).and_then(|p| centres.get(p).copied()).unwrap_or(anchor);
|
||||
let lay = dim_layout(&frame, c.text.or_else(|| default_text(&frame, away, px)), px, half);
|
||||
let stroke = Stroke::new(1.0, col);
|
||||
let mut segs = Vec::new();
|
||||
for line in &lay.lines {
|
||||
let pts: Vec<Pos2> = line.iter().filter_map(|q| to(*q)).collect();
|
||||
for w in pts.windows(2) {
|
||||
segs.push([w[0], w[1]]);
|
||||
}
|
||||
painter.add(Shape::line(pts, stroke));
|
||||
}
|
||||
for (tip, dir) in &lay.arrows {
|
||||
if let (Some(t), Some(back)) = (to(*tip), to(*tip - *dir * px)) {
|
||||
let d = (t - back).normalized();
|
||||
let n = vec2(-d.y, d.x);
|
||||
painter.add(Shape::convex_polygon(vec![t, t - d * 9.0 + n * 3.0, t - d * 9.0 - n * 3.0], col, Stroke::NONE));
|
||||
}
|
||||
}
|
||||
let Some(tc) = to(lay.text) else { continue };
|
||||
let r = Rect::from_center_size(tc, size);
|
||||
painter.rect_filled(r, 2.0, tk.viewport_top.gamma_multiply(0.85));
|
||||
painter.galley(r.min + vec2(3.0, 1.0), galley, col);
|
||||
if matches!(frame, DimFrame::ArcLength { .. }) {
|
||||
// The arc-length mark over the value.
|
||||
let c0 = pos2_mid_top(r);
|
||||
let pts: Vec<Pos2> = (0..=12)
|
||||
.map(|i| c0 + vec2(5.0 * (std::f32::consts::PI * i as f32 / 12.0).cos(), -3.0 * (std::f32::consts::PI * i as f32 / 12.0).sin()))
|
||||
.collect();
|
||||
painter.add(Shape::line(pts, stroke));
|
||||
}
|
||||
drawn.push(Drawn { id: c.id.clone(), param: c.param.clone(), text: r, segs, at: lay.text });
|
||||
}
|
||||
DRAWN.with(|d| *d.borrow_mut() = drawn);
|
||||
edit_box(app, ui.ctx());
|
||||
}
|
||||
|
||||
/// A point a dimension measures (for the shape it belongs to).
|
||||
fn first_point(sk: &solvecraft_engine::sketch::Sketch, k: &ConstraintKind) -> Option<usize> {
|
||||
use ConstraintKind::*;
|
||||
match *k {
|
||||
Length { l, .. } => sk.curves.get(l).and_then(|c| c.kind.point_ids().first().copied()),
|
||||
Distance { p, .. } | DistanceX { p, .. } | DistanceY { p, .. } | PointLineDistance { p, .. } | LinearDiameter { p, .. } => Some(p),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn pos2_mid_top(r: Rect) -> Pos2 {
|
||||
Pos2::new(r.center().x, r.top() - 1.0)
|
||||
}
|
||||
|
||||
/// The inline value editor: Enter applies, Esc (or a click elsewhere) cancels.
|
||||
fn edit_box(app: &mut SolveApp, ctx: &egui::Context) {
|
||||
let Some(mut e) = EDIT.with(|x| x.borrow_mut().take()) else { return };
|
||||
let id = egui::Id::new("sc_dim_edit");
|
||||
let mut done: Option<bool> = None;
|
||||
egui::Area::new(egui::Id::new("sc_dim_edit_area")).fixed_pos(e.at - vec2(45.0, 11.0)).order(egui::Order::Foreground).show(ctx, |ui| {
|
||||
egui::Frame::popup(ui.style()).inner_margin(egui::Margin::symmetric(3, 1)).show(ui, |ui| {
|
||||
let r = ui.add(egui::TextEdit::singleline(&mut e.expr).id(id).desired_width(90.0));
|
||||
crate::params_dialog::complete(ui, &r, &mut e.expr);
|
||||
if e.fresh == FRESH {
|
||||
// The whole value is selected, so typing replaces it.
|
||||
let n = e.expr.chars().count();
|
||||
let mut s = egui::text_edit::TextEditState::load(ui.ctx(), id).unwrap_or_default();
|
||||
s.cursor.set_char_range(Some(egui::text_selection::CCursorRange::two(egui::text::CCursor::new(0), egui::text::CCursor::new(n))));
|
||||
s.store(ui.ctx(), id);
|
||||
}
|
||||
let enter = ui.input(|i| i.key_pressed(egui::Key::Enter));
|
||||
if r.lost_focus() && enter {
|
||||
done = Some(true);
|
||||
} else if e.fresh > 0 {
|
||||
if !r.has_focus() {
|
||||
r.request_focus();
|
||||
}
|
||||
} else if r.lost_focus() {
|
||||
done = Some(false);
|
||||
}
|
||||
if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
|
||||
done = Some(false);
|
||||
}
|
||||
});
|
||||
});
|
||||
e.fresh = e.fresh.saturating_sub(1);
|
||||
match done {
|
||||
Some(true) => {
|
||||
if let Err(err) = app.run("ChangeParameterCommand", json!({"name": e.param, "expression": e.expr})) {
|
||||
app.set_status(err, true);
|
||||
EDIT.with(|x| *x.borrow_mut() = Some(Edit { fresh: FRESH, ..e }));
|
||||
}
|
||||
}
|
||||
Some(false) => {}
|
||||
None => EDIT.with(|x| *x.borrow_mut() = Some(e)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Is the inline editor open (it has the keyboard)?
|
||||
pub fn editing() -> bool {
|
||||
EDIT.with(|e| e.borrow().is_some())
|
||||
}
|
||||
|
||||
/// Dimensions drawn last frame: (id, text centre on screen), for tests and the control channel.
|
||||
pub fn drawn() -> Vec<(String, Pos2)> {
|
||||
DRAWN.with(|d| d.borrow().iter().map(|x| (x.id.clone(), x.text.center())).collect())
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn labels_show_the_value_or_fx() {
|
||||
let k = ConstraintKind::Length { l: 0, value: 25.0 };
|
||||
assert_eq!(label(&k, Some("25 mm"), false), "25.00");
|
||||
assert_eq!(label(&k, Some("width * 2"), false), "fx: 25.00");
|
||||
assert_eq!(label(&k, None, true), "(25.00)");
|
||||
assert_eq!(label(&ConstraintKind::Radius { c: 0, value: 5.0 }, Some("5 mm"), false), "R5.00");
|
||||
assert_eq!(label(&ConstraintKind::Diameter { c: 0, value: 10.0 }, Some("10"), false), "Ø10.00");
|
||||
let a = ConstraintKind::Angle { a: 0, b: 1, value: std::f64::consts::FRAC_PI_4, flip: false };
|
||||
assert_eq!(label(&a, Some("45 deg"), false), "45.0°");
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user