a770fa5a5e5f
annotate_dimedit.rs
//! Dimension edits: DIMEDIT (Home/New/Rotate/Oblique), DIMJOGGED, DIMJOGLINE, DIMBREAK and
//! DIMINSPECT. Each has a JSON form; the prompt sequences run the same JSON form.
use cadcraft_doc::{DimBreak, DimKind, Dimension, EntityKind, Handle, Inspection, JoggedRadius, Prim};
use cadcraft_geom::{Segment, Vec2};
use serde_json::{Value, json};
use super::super::helpers::v3;
use super::super::machines::{SelOutcome, SelectPhase};
use super::super::{CommandSpec, bad, bool_or, point_param, point_req, size_param, str_param, targets};
use super::{DimText, add_dim, circle_of, dim, dims_of, pick_at};
use crate::{Accept, Input, Interactive, Prompt, Result, Session, Step};
/// Most objects DIMBREAK Auto looks at, and most breaks it adds to one dimension.
const MAX_BREAK_OBJECTS: usize = 20_000;
const MAX_AUTO_BREAKS: usize = 1000;
pub(super) fn specs() -> Vec<CommandSpec> {
vec![
CommandSpec::new("dimedit", "Dimension Edit", run_dimedit)
.alias(&["ded", "dimed"])
.params("{handles?, mode?: home|new|rotate|oblique (default home), text? (new: \"\" or \"<>\" = the measurement), angle?: degrees (rotate: text angle; oblique: extension line angle, absent = none)}")
.interactive(|_| Ok(Box::new(DimEditM::new(None)))),
CommandSpec::new("dimedit.oblique", "Oblique", |s, p| run_dimedit(s, &with_mode(p, "oblique")))
.menu(&["Dimension", "Oblique"])
.params("{handles?, angle?: degrees}")
.interactive(|_| Ok(Box::new(DimEditM::new(Some(Mode::Oblique))))),
CommandSpec::new("dimjogged", "Jogged", run_jogged)
.menu(&["Dimension", "Jogged"])
.alias(&["djo", "jog"])
.params("{handle (arc or circle), centerOverride: [x,y], at: [x,y] (dimension line location), jog?: [x,y], text?}")
.interactive(|_| Ok(Box::new(JoggedM::default()))),
CommandSpec::new("dimjogline", "Jogged Linear", run_jogline)
.menu(&["Dimension", "Jogged Linear"])
.alias(&["djl"])
.params("{handle (linear or aligned dimension), at?: [x,y] (jog location; default between the text and the first extension line), remove?: bool}")
.interactive(|_| Ok(Box::new(JogLineM::default()))),
CommandSpec::new("dimbreak", "Dimension Break", run_dimbreak)
.menu(&["Dimension", "Dimension Break"])
.params("{handles?, mode?: auto|manual|remove (default auto), objects?: [hex] (auto: the objects that break; default all crossing objects), first?/second?: [x,y] (manual), size?: number (default 0.125 × DIMSCALE)}")
.interactive(|_| Ok(Box::new(DimBreakM::default()))),
CommandSpec::new("diminspect", "Inspection", run_diminspect)
.menu(&["Dimension", "Inspection"])
.params("{handles?, shape?: round|angular|none (default round), label?: string, rate?: string (default \"100%\"), remove?: bool}")
.interactive(|_| Ok(Box::new(InspectM::default()))),
]
}
fn with_mode(p: &Value, mode: &str) -> Value {
let mut p = p.clone();
if let Some(o) = p.as_object_mut() {
o.insert("mode".into(), json!(mode));
}
p
}
fn handles_json(hs: &[Handle]) -> Value {
json!(hs.iter().map(|h| h.hex()).collect::<Vec<_>>())
}
/// Change each dimension of `hs` with `f` (its block regenerated); returns how many changed.
fn edit_dims(s: &mut Session, hs: &[Handle], f: &dyn Fn(&mut Dimension) -> bool) -> Result<usize> {
let d = s.doc_mut()?;
let mut n = 0;
for h in hs {
let mut changed = false;
d.modify_entity(*h, |e| {
if let EntityKind::Dimension(dm) = &mut e.kind
&& f(dm)
{
dm.block = None;
changed = true;
}
})?;
n += usize::from(changed);
}
Ok(n)
}
fn is_linear(dm: &Dimension) -> bool {
matches!(dm.kind, DimKind::Linear { .. } | DimKind::Aligned)
}
// ---------------- DIMEDIT ----------------
#[derive(Clone, Copy, Debug, PartialEq)]
enum Mode {
Home,
New,
Rotate,
Oblique,
}
fn run_dimedit(s: &mut Session, p: &Value) -> Result<Value> {
let hs = dims_of(s, &targets(s, p)?);
if hs.is_empty() {
return Err(bad("dimedit", "select dimensions"));
}
let mode = str_param(p, "mode").unwrap_or("home").to_ascii_lowercase();
let angle = match p.get("angle") {
None | Some(Value::Null) => None,
Some(v) => Some(v.as_f64().filter(|a| a.is_finite()).ok_or_else(|| bad("dimedit", "`angle` must be a number (degrees)"))?.to_radians()),
};
let n = match mode.as_str() {
"home" => edit_dims(s, &hs, &|dm| {
dm.user_text_pos = false;
dm.text_rotation = 0.0;
dm.overrides.remove("textJust");
true
})?,
"new" => {
let t = str_param(p, "text").unwrap_or("").to_string();
// "<>" alone is the measurement, which is what no override text means.
let t = if t.trim() == "<>" { String::new() } else { t };
edit_dims(s, &hs, &|dm| {
dm.text = t.clone();
true
})?
}
"rotate" => {
let a = angle.ok_or_else(|| bad("dimedit", "`angle` (degrees) is required"))?;
edit_dims(s, &hs, &|dm| {
dm.text_rotation = cadcraft_geom::norm_angle(a);
true
})?
}
"oblique" => edit_dims(s, &hs, &|dm| {
if !is_linear(dm) {
return false;
}
dm.marks.oblique = angle.map(cadcraft_geom::norm_angle);
true
})?,
other => return Err(bad("dimedit", format!("unknown mode `{other}` (home, new, rotate, oblique)"))),
};
Ok(json!({ "changed": n }))
}
/// DIMEDIT at the command line: the kind of edit, then (New) the text or (Rotate) the angle,
/// the dimensions, and (Oblique) the extension line angle.
struct DimEditM {
mode: Option<Mode>,
text: Option<String>,
angle: Option<f64>,
selecting: Option<SelectPhase>,
picked: Vec<Handle>,
}
impl DimEditM {
fn new(mode: Option<Mode>) -> Self {
DimEditM { mode, text: None, angle: None, selecting: None, picked: Vec::new() }
}
/// "Select objects", or the pickfirst selection at once.
fn select(&mut self, s: &mut Session) -> Result<Step> {
let ph = SelectPhase::begin(s);
if ph.done {
return self.after_selection(s, ph.picked);
}
self.selecting = Some(ph);
Ok(Step::Continue)
}
fn run(&self, s: &mut Session, hs: &[Handle], angle: Option<f64>) -> Result<Step> {
let (mode, extra) = match self.mode {
Some(Mode::New) => ("new", json!({ "text": self.text.clone().unwrap_or_default() })),
Some(Mode::Rotate) => ("rotate", json!({ "angle": angle.unwrap_or(0.0).to_degrees() })),
Some(Mode::Oblique) => ("oblique", json!({ "angle": angle.map(f64::to_degrees) })),
_ => ("home", json!({})),
};
let mut p = extra;
if let Some(o) = p.as_object_mut() {
o.insert("handles".into(), handles_json(hs));
o.insert("mode".into(), json!(mode));
}
let r = run_dimedit(s, &p)?;
s.echo(format!("{} dimension(s) changed.", r.get("changed").and_then(Value::as_u64).unwrap_or(0)));
s.set_selection(Vec::new());
Ok(Step::Done)
}
fn after_selection(&mut self, s: &mut Session, hs: Vec<Handle>) -> Result<Step> {
let hs = dims_of(s, &hs);
if hs.is_empty() {
s.echo("No dimensions selected.");
return Ok(Step::Done);
}
if self.mode == Some(Mode::Oblique) {
self.picked = hs;
return Ok(Step::Continue);
}
self.run(s, &hs, self.angle)
}
}
impl Interactive for DimEditM {
fn name(&self) -> &'static str {
"DIMEDIT"
}
fn begin(&mut self, s: &mut Session) -> Result<Step> {
// Dimension ▸ Oblique asks for the dimensions first.
if self.mode == Some(Mode::Oblique) {
return self.select(s);
}
Ok(Step::Continue)
}
fn prompt(&self, _s: &Session) -> Prompt {
if let Some(sel) = &self.selecting {
return sel.prompt();
}
match self.mode {
None => Prompt::new("Enter type of dimension editing", Accept::TEXT).kw(&["Home", "New", "Rotate", "Oblique"]).default("Home"),
Some(Mode::New) => Prompt::new("Enter new dimension text", Accept::TEXT).default("<>"),
Some(Mode::Rotate) => Prompt::new("Specify angle for dimension text", Accept::NUMBER),
_ => Prompt::new("Enter obliquing angle (press ENTER for none)", Accept::NUMBER),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
if let Some(sel) = &mut self.selecting {
return match sel.feed(s, &i)? {
SelOutcome::More => Ok(Step::Continue),
SelOutcome::Empty => Ok(Step::Done),
SelOutcome::Done(hs) => {
self.selecting = None;
self.after_selection(s, hs)
}
};
}
match (self.mode, i) {
(None, Input::Keyword(k)) => {
self.mode = match k.as_str() {
"New" => Some(Mode::New),
"Rotate" => Some(Mode::Rotate),
"Oblique" => Some(Mode::Oblique),
_ => Some(Mode::Home),
};
if matches!(self.mode, Some(Mode::Home | Mode::Oblique)) {
return self.select(s);
}
}
(None, Input::Enter) => {
self.mode = Some(Mode::Home);
return self.select(s);
}
(None, Input::Text(_)) => s.echo("Invalid option keyword."),
(Some(Mode::New), Input::Text(t)) if self.text.is_none() => {
self.text = Some(t);
return self.select(s);
}
(Some(Mode::New), Input::Enter) if self.text.is_none() => {
self.text = Some(String::new());
return self.select(s);
}
(Some(Mode::Rotate), Input::Text(t)) if self.angle.is_none() => match s.angle_settings().direction(&t) {
Some(a) => {
self.angle = Some(a);
return self.select(s);
}
None => s.echo("Requires a valid angle."),
},
(Some(Mode::Oblique), Input::Text(t)) if !self.picked.is_empty() => match s.angle_settings().direction(&t) {
Some(a) => return self.run(s, &self.picked.clone(), Some(a)),
None => s.echo("Requires a valid angle."),
},
(Some(Mode::Oblique), Input::Enter) if !self.picked.is_empty() => return self.run(s, &self.picked.clone(), None),
(_, Input::Cancel) => return Ok(Step::Cancel),
(Some(_), Input::Enter) => return Ok(Step::Cancel),
_ => {}
}
Ok(Step::Continue)
}
fn preview(&self, _s: &Session, _c: Vec2) -> Vec<EntityKind> {
Vec::new()
}
}
// ---------------- DIMJOGGED ----------------
/// A jogged radius dimension of the circle (`c`, `r`): the arrow where the direction of `at`
/// meets it, the line from `center` (the override) with a jog at `jog` (default halfway).
fn jogged_kind(s: &Session, c: Vec2, r: f64, center: Vec2, at: Vec2, jog: Option<Vec2>, text: &str) -> Option<EntityKind> {
let dir = (at - c).normalized();
if dir == Vec2::ZERO || !dir.is_finite() || r.is_nan() || r <= 0.0 {
return None;
}
let tip = c + dir * r;
let jog = jog.unwrap_or_else(|| center.mid(tip));
let mut k = dim(s, DimKind::Radius, c, Vec2::ZERO, Vec2::ZERO, tip, text);
if let EntityKind::Dimension(dm) = &mut k {
dm.marks.jogged = Some(JoggedRadius { center: v3(center), jog: v3(jog) });
if at.dist(c) > r + 1e-9 {
dm.text_mid = v3(at);
dm.user_text_pos = true;
}
}
Some(k)
}
fn run_jogged(s: &mut Session, p: &Value) -> Result<Value> {
let h = targets(s, p)?.first().copied().ok_or_else(|| bad("dimjogged", "`handle` of an arc or circle is required"))?;
let (c, r) = circle_of(s, h).ok_or_else(|| bad("dimjogged", "object is not a circle or arc"))?;
let center = point_req("dimjogged", p, "centerOverride")?;
let at = point_req("dimjogged", p, "at")?;
let k = jogged_kind(s, c, r, center, at, point_param(p, "jog"), str_param(p, "text").unwrap_or(""))
.ok_or_else(|| bad("dimjogged", "`at` must differ from the centre"))?;
Ok(json!({ "handle": add_dim(s, k)?.hex() }))
}
#[derive(Default)]
struct JoggedM {
circle: Option<(Vec2, f64)>,
center: Option<Vec2>,
at: Option<Vec2>,
text: DimText,
}
impl Interactive for JoggedM {
fn name(&self) -> &'static str {
"DIMJOGGED"
}
fn prompt(&self, _s: &Session) -> Prompt {
if let Some(p) = self.text.prompt() {
return p;
}
match (self.circle, self.center, self.at) {
(None, ..) => Prompt::new("Select arc or circle", Accept::POINT),
(Some((c, _)), None, _) => Prompt::new("Specify center location override", Accept::POINT).base(c),
(Some(_), Some(o), None) => Prompt::new("Specify dimension line location", Accept::POINT).kw(&["Mtext", "Text", "Angle"]).base(o),
(Some(_), Some(o), Some(_)) => Prompt::new("Specify jog location", Accept::POINT).base(o),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
if self.text.answer(s, &i) {
return Ok(Step::Continue);
}
match (self.circle, self.center, self.at, i) {
(None, _, _, Input::Point(p)) => match pick_at(s, p).and_then(|h| circle_of(s, h)) {
Some(t) => self.circle = Some(t),
None => s.echo("Object selected is not a circle or arc."),
},
(Some(_), None, _, Input::Point(p)) => self.center = Some(p),
(Some(_), Some(_), None, Input::Keyword(k)) => {
self.text.keyword(&k);
}
(Some(_), Some(_), None, Input::Point(p)) => self.at = Some(p),
(Some((c, r)), Some(o), Some(at), Input::Point(j)) => {
if let Some(k) = jogged_kind(s, c, r, o, at, Some(j), "") {
add_dim(s, self.text.apply(k))?;
}
return Ok(Step::Done);
}
(_, _, _, Input::Enter | Input::Cancel) => return Ok(Step::Cancel),
_ => {}
}
Ok(Step::Continue)
}
fn preview(&self, s: &Session, p: Vec2) -> Vec<EntityKind> {
let Some((c, r)) = self.circle else { return Vec::new() };
let (o, at, jog) = match (self.center, self.at) {
(Some(o), None) => (o, p, None),
(Some(o), Some(at)) => (o, at, Some(p)),
_ => return Vec::new(),
};
jogged_kind(s, c, r, o, at, jog, "").map(|k| vec![self.text.apply(k)]).unwrap_or_default()
}
}
// ---------------- DIMJOGLINE ----------------
/// Where a dimension line meets the first extension line, and the dimension line direction.
fn first_foot(dm: &Dimension) -> Option<(Vec2, Vec2)> {
let dir = match dm.kind {
DimKind::Linear { rotation } => Vec2::from_angle(rotation),
DimKind::Aligned => (dm.p14.xy() - dm.p13.xy()).normalized(),
_ => return None,
};
if dir == Vec2::ZERO || !dir.is_finite() {
return None;
}
let on = dm.defpt.xy();
Some((on + dir * (dm.p13.xy() - on).dot(dir), dir))
}
fn run_jogline(s: &mut Session, p: &Value) -> Result<Value> {
let hs = dims_of(s, &targets(s, p)?);
let h = *hs.first().ok_or_else(|| bad("dimjogline", "`handle` of a linear or aligned dimension is required"))?;
let d = s.doc()?;
let Some(EntityKind::Dimension(dm)) = d.entity(h).map(|e| &e.kind) else { return Err(bad("dimjogline", "not a dimension")) };
let (f1, dir) = first_foot(dm).ok_or_else(|| bad("dimjogline", "only linear and aligned dimensions take a jog"))?;
let remove = bool_or(p, "remove", false);
let at = match point_param(p, "at") {
Some(at) => at,
None => {
// Halfway between the text and the first extension line.
let t = cadcraft_render::dimension_in(d, dm).text_pos;
f1.mid(f1 + dir * (t - f1).dot(dir))
}
};
edit_dims(s, &[h], &|dm| {
dm.marks.jog_line = if remove { None } else { Some(v3(at)) };
true
})?;
Ok(json!({ "handle": h.hex() }))
}
#[derive(Default)]
struct JogLineM {
dim: Option<Handle>,
removing: bool,
}
impl Interactive for JogLineM {
fn name(&self) -> &'static str {
"DIMJOGLINE"
}
fn prompt(&self, _s: &Session) -> Prompt {
match (self.dim, self.removing) {
(None, false) => Prompt::new("Select dimension to add jog", Accept::SELECT).kw(&["Remove"]),
(None, true) => Prompt::new("Select jog to remove", Accept::SELECT),
(Some(_), _) => Prompt::new("Specify jog location (or press ENTER)", Accept::POINT),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
match (self.dim, i) {
(None, Input::Keyword(k)) if k == "Remove" => self.removing = true,
(None, Input::Pick(hs)) => {
let lin = |s: &Session, h: Handle| {
s.doc().ok().and_then(|d| d.entity(h)).is_some_and(|e| matches!(&e.kind, EntityKind::Dimension(dm) if is_linear(dm)))
};
match dims_of(s, &hs).into_iter().find(|h| lin(s, *h)) {
Some(h) if self.removing => {
run_jogline(s, &json!({ "handle": h.hex(), "remove": true }))?;
return Ok(Step::Done);
}
Some(h) => self.dim = Some(h),
None if hs.is_empty() => {}
None => s.echo("Select a linear or aligned dimension."),
}
}
(Some(h), Input::Point(at)) => {
run_jogline(s, &json!({ "handle": h.hex(), "at": [at.x, at.y] }))?;
return Ok(Step::Done);
}
(Some(h), Input::Enter) => {
run_jogline(s, &json!({ "handle": h.hex() }))?;
return Ok(Step::Done);
}
(_, Input::Enter | Input::Cancel) => return Ok(Step::Cancel),
_ => {}
}
Ok(Step::Continue)
}
fn preview(&self, _s: &Session, _c: Vec2) -> Vec<EntityKind> {
Vec::new()
}
}
// ---------------- DIMBREAK ----------------
/// Where the dimension's drawn lines cross the objects: (point, direction of the line there).
fn crossings(dm_lines: &[Vec<Vec2>], prims: &[Prim]) -> Vec<Vec2> {
let mut out = Vec::new();
for l in dm_lines {
for w in l.windows(2) {
let seg = Segment::Line(cadcraft_geom::Line::new(w[0], w[1]));
for p in prims {
let pts = match p {
Prim::Seg(o) => cadcraft_geom::intersect_segments(&seg, o),
Prim::Circle(c) => cadcraft_geom::line_circle(&cadcraft_geom::Line::new(w[0], w[1]), c)
.into_iter()
.filter(|(_, t)| (-1e-9..=1.0 + 1e-9).contains(t))
.map(|(q, _)| q)
.collect(),
Prim::Infinite { base, dir, ray } => cadcraft_geom::line_line_infinite(w[0], w[1], *base, *base + *dir)
.filter(|(_, t, u)| (-1e-9..=1.0 + 1e-9).contains(t) && (!ray || *u >= -1e-9))
.map(|(q, _, _)| vec![q])
.unwrap_or_default(),
_ => Vec::new(),
};
for q in pts {
if out.len() >= MAX_AUTO_BREAKS {
return out;
}
if !out.iter().any(|o: &Vec2| o.dist(q) < 1e-9) {
out.push(q);
}
}
}
}
}
out
}
fn run_dimbreak(s: &mut Session, p: &Value) -> Result<Value> {
let hs = dims_of(s, &targets(s, p)?);
if hs.is_empty() {
return Err(bad("dimbreak", "select dimensions"));
}
let mode = str_param(p, "mode").unwrap_or("auto").to_ascii_lowercase();
let d = s.doc()?;
let size = match size_param("dimbreak", p, "size", false)? {
Some(x) => x,
None => 0.125 * Some(d.header.f64("DIMSCALE", 1.0)).filter(|k| *k > 0.0 && *k < 1e12).unwrap_or(1.0),
};
match mode.as_str() {
"remove" => {
let n = edit_dims(s, &hs, &|dm| {
let had = !dm.marks.breaks.is_empty();
dm.marks.breaks.clear();
had
})?;
Ok(json!({ "changed": n }))
}
"manual" => {
let (a, b) = (point_req("dimbreak", p, "first")?, point_req("dimbreak", p, "second")?);
if a.near(b, 1e-12) {
return Err(bad("dimbreak", "`first` and `second` must differ"));
}
let br = DimBreak { at: v3(a.mid(b)), size: a.dist(b), auto: false };
let n = edit_dims(s, &hs[..1], &|dm| {
dm.marks.breaks.push(br.clone());
true
})?;
Ok(json!({ "changed": n }))
}
"auto" => {
// The breaking objects: those given, else every object (not a dimension or text).
let given: Option<Vec<Handle>> = match p.get("objects") {
None | Some(Value::Null) => None,
Some(_) => Some(targets(s, &json!({ "handles": p.get("objects") }))?),
};
let space = s.space();
let store = d.space(&space).ok_or_else(|| bad("dimbreak", "no current space"))?;
let others: Vec<(Handle, Vec<Prim>)> = store
.iter()
.filter(|e| match &given {
Some(g) => g.contains(&e.handle),
None => !matches!(e.kind, EntityKind::Dimension(_) | EntityKind::Text(_) | EntityKind::MText(_)),
})
.take(MAX_BREAK_OBJECTS)
.map(|e| (e.handle, e.kind.prims()))
.collect();
let mut plan = Vec::new();
for h in &hs {
let Some(EntityKind::Dimension(dm)) = d.entity(*h).map(|e| &e.kind) else { continue };
let mut plain = dm.clone();
plain.marks.breaks.clear();
let g = cadcraft_render::dimension_in(d, &plain);
let prims: Vec<Prim> = others.iter().filter(|(o, _)| o != h).flat_map(|(_, p)| p.iter().cloned()).collect();
plan.push((*h, crossings(&g.lines, &prims)));
}
let mut n = 0;
for (h, pts) in plan {
n += edit_dims(s, &[h], &|dm| {
dm.marks.breaks.retain(|b| !b.auto);
dm.marks.breaks.extend(pts.iter().map(|q| DimBreak { at: v3(*q), size, auto: true }));
true
})?;
}
Ok(json!({ "changed": n }))
}
other => Err(bad("dimbreak", format!("unknown mode `{other}` (auto, manual, remove)"))),
}
}
#[derive(Default)]
struct DimBreakM {
dims: Vec<Handle>,
multiple: Option<SelectPhase>,
objects: Vec<Handle>,
manual: Vec<Vec2>,
manual_mode: bool,
}
impl DimBreakM {
fn run(&self, s: &mut Session, mut p: Value) -> Result<Step> {
if let Some(o) = p.as_object_mut() {
o.insert("handles".into(), handles_json(&self.dims));
}
let r = run_dimbreak(s, &p)?;
s.echo(format!("{} dimension(s) changed.", r.get("changed").and_then(Value::as_u64).unwrap_or(0)));
s.set_selection(Vec::new());
Ok(Step::Done)
}
}
impl Interactive for DimBreakM {
fn name(&self) -> &'static str {
"DIMBREAK"
}
fn prompt(&self, _s: &Session) -> Prompt {
if let Some(sel) = &self.multiple {
return sel.prompt();
}
if self.dims.is_empty() {
return Prompt::new("Select dimension to add/remove break", Accept::SELECT).kw(&["Multiple"]);
}
if self.manual_mode {
return Prompt::new(if self.manual.is_empty() { "Specify first break point" } else { "Specify second break point" }, Accept::POINT)
.base_opt(self.manual.first().copied());
}
if self.objects.is_empty() {
let kws: &[&str] = if self.dims.len() == 1 { &["Auto", "Manual", "Remove"] } else { &["Auto", "Remove"] };
Prompt::new("Select object to break dimension", Accept::SELECT).kw(kws).default("Auto")
} else {
Prompt::new("Select object to break dimension", Accept::SELECT)
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
if let Some(sel) = &mut self.multiple {
return match sel.feed(s, &i)? {
SelOutcome::More => Ok(Step::Continue),
SelOutcome::Empty => Ok(Step::Done),
SelOutcome::Done(hs) => {
self.multiple = None;
self.dims = dims_of(s, &hs);
Ok(if self.dims.is_empty() { Step::Done } else { Step::Continue })
}
};
}
if self.dims.is_empty() {
match i {
Input::Keyword(k) if k == "Multiple" => self.multiple = Some(SelectPhase::default()),
Input::Pick(hs) => match dims_of(s, &hs).first() {
Some(h) => self.dims = vec![*h],
None if hs.is_empty() => {}
None => s.echo("Object selected is not a dimension."),
},
Input::Enter | Input::Cancel => return Ok(Step::Cancel),
_ => {}
}
return Ok(Step::Continue);
}
if self.manual_mode {
return match i {
Input::Point(p) if self.manual.is_empty() => {
self.manual.push(p);
Ok(Step::Continue)
}
Input::Point(p) => {
let a = self.manual.first().copied().unwrap_or(p);
self.run(s, json!({ "mode": "manual", "first": [a.x, a.y], "second": [p.x, p.y] }))
}
Input::Enter | Input::Cancel => Ok(Step::Cancel),
_ => Ok(Step::Continue),
};
}
match i {
Input::Keyword(k) if k == "Auto" => return self.run(s, json!({ "mode": "auto" })),
Input::Keyword(k) if k == "Remove" => return self.run(s, json!({ "mode": "remove" })),
Input::Keyword(k) if k == "Manual" => self.manual_mode = true,
Input::Pick(hs) => {
for h in hs {
if !self.dims.contains(&h) && !self.objects.contains(&h) {
self.objects.push(h);
}
}
}
Input::Enter if self.objects.is_empty() => return self.run(s, json!({ "mode": "auto" })),
Input::Enter => return self.run(s, json!({ "mode": "auto", "objects": handles_json(&self.objects) })),
Input::Cancel => return Ok(Step::Cancel),
_ => {}
}
Ok(Step::Continue)
}
fn preview(&self, _s: &Session, _c: Vec2) -> Vec<EntityKind> {
Vec::new()
}
}
// ---------------- DIMINSPECT ----------------
fn run_diminspect(s: &mut Session, p: &Value) -> Result<Value> {
let hs = dims_of(s, &targets(s, p)?);
if hs.is_empty() {
return Err(bad("diminspect", "select dimensions"));
}
if bool_or(p, "remove", false) {
let n = edit_dims(s, &hs, &|dm| dm.marks.inspect.take().is_some())?;
return Ok(json!({ "changed": n }));
}
let shape = match str_param(p, "shape").unwrap_or("round").to_ascii_lowercase().as_str() {
"round" => 0,
"angular" => 1,
"none" => 2,
other => return Err(bad("diminspect", format!("unknown shape `{other}` (round, angular, none)"))),
};
let cap = |t: &str| t.chars().take(256).collect::<String>();
let ins = Inspection { shape, label: cap(str_param(p, "label").unwrap_or("")), rate: cap(str_param(p, "rate").unwrap_or("100%")) };
let n = edit_dims(s, &hs, &|dm| {
dm.marks.inspect = Some(ins.clone());
true
})?;
Ok(json!({ "changed": n }))
}
/// DIMINSPECT at the command line: the dimensions, then shape (or Remove), label and rate.
#[derive(Default)]
struct InspectM {
selecting: Option<SelectPhase>,
dims: Vec<Handle>,
shape: Option<&'static str>,
label: Option<String>,
}
impl Interactive for InspectM {
fn name(&self) -> &'static str {
"DIMINSPECT"
}
fn begin(&mut self, s: &mut Session) -> Result<Step> {
let ph = SelectPhase::begin(s);
if ph.done {
self.dims = dims_of(s, &ph.picked);
if self.dims.is_empty() {
return Ok(Step::Done);
}
} else {
self.selecting = Some(ph);
}
Ok(Step::Continue)
}
fn prompt(&self, _s: &Session) -> Prompt {
if let Some(sel) = &self.selecting {
return sel.prompt();
}
match (self.shape, &self.label) {
(None, _) => Prompt::new("Enter inspection shape", Accept::TEXT).kw(&["Round", "Angular", "None", "Remove"]).default("Round"),
(Some(_), None) => Prompt::new("Enter label (press ENTER for none)", Accept::TEXT),
(Some(_), Some(_)) => Prompt::new("Enter inspection rate", Accept::TEXT).default("100%"),
}
}
fn input(&mut self, s: &mut Session, i: Input) -> Result<Step> {
if let Some(sel) = &mut self.selecting {
return match sel.feed(s, &i)? {
SelOutcome::More => Ok(Step::Continue),
SelOutcome::Empty => Ok(Step::Done),
SelOutcome::Done(hs) => {
self.selecting = None;
self.dims = dims_of(s, &hs);
if self.dims.is_empty() {
s.echo("No dimensions selected.");
return Ok(Step::Done);
}
Ok(Step::Continue)
}
};
}
let handles = handles_json(&self.dims);
match (self.shape, self.label.clone(), i) {
(None, _, Input::Keyword(k)) if k == "Remove" => {
run_diminspect(s, &json!({ "handles": handles, "remove": true }))?;
s.set_selection(Vec::new());
return Ok(Step::Done);
}
(None, _, Input::Keyword(k)) => {
self.shape = Some(match k.as_str() {
"Angular" => "angular",
"None" => "none",
_ => "round",
})
}
(None, _, Input::Enter) => self.shape = Some("round"),
(Some(_), None, Input::Text(t)) => self.label = Some(t),
(Some(_), None, Input::Enter) => self.label = Some(String::new()),
(Some(shape), Some(label), Input::Text(t)) => {
run_diminspect(s, &json!({ "handles": handles, "shape": shape, "label": label, "rate": t }))?;
s.set_selection(Vec::new());
return Ok(Step::Done);
}
(Some(shape), Some(label), Input::Enter) => {
run_diminspect(s, &json!({ "handles": handles, "shape": shape, "label": label }))?;
s.set_selection(Vec::new());
return Ok(Step::Done);
}
(_, _, Input::Cancel) => return Ok(Step::Cancel),
_ => {}
}
Ok(Step::Continue)
}
fn preview(&self, _s: &Session, _c: Vec2) -> Vec<EntityKind> {
Vec::new()
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.